[mirror_edk2.git] / FatPkg / EnhancedFatDxe / DiskCache.c

/** @file\r
  Cache implementation for EFI FAT File system driver.\r
\r
Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials are licensed and made available\r
under the terms and conditions of the BSD License which accompanies this\r
distribution. The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "Fat.h"\r
\r
/**\r
\r
  This function is used by the Data Cache.\r
\r
  When this function is called by write command, all entries in this range\r
  are older than the contents in disk, so they are invalid; just mark them invalid.\r
\r
  When this function is called by read command, if any entry in this range\r
  is dirty, it means that the relative info directly readed from media is older than\r
  than the info in the cache; So need to update the relative info in the Buffer.\r
\r
  @param  Volume                - FAT file system volume.\r
  @param  IoMode                - This function is called by read command or write command\r
  @param  StartPageNo           - First PageNo to be checked in the cache.\r
  @param  EndPageNo             - Last PageNo to be checked in the cache.\r
  @param  Buffer                - The user buffer need to update. Only when doing the read command\r
                          and there is dirty cache in the cache range, this parameter will be used.\r
\r
**/\r
STATIC\r
VOID\r
FatFlushDataCacheRange (\r
  IN  FAT_VOLUME         *Volume,\r
  IN  IO_MODE            IoMode,\r
  IN  UINTN              StartPageNo,\r
  IN  UINTN              EndPageNo,\r
  OUT UINT8              *Buffer\r
  )\r
{\r
  UINTN       PageNo;\r
  UINTN       GroupNo;\r
  UINTN       GroupMask;\r
  UINTN       PageSize;\r
  UINT8       PageAlignment;\r
  DISK_CACHE  *DiskCache;\r
  CACHE_TAG   *CacheTag;\r
  UINT8       *BaseAddress;\r
\r
  DiskCache     = &Volume->DiskCache[CacheData];\r
  BaseAddress   = DiskCache->CacheBase;\r
  GroupMask     = DiskCache->GroupMask;\r
  PageAlignment = DiskCache->PageAlignment;\r
  PageSize      = (UINTN)1 << PageAlignment;\r
\r
  for (PageNo = StartPageNo; PageNo < EndPageNo; PageNo++) {\r
    GroupNo   = PageNo & GroupMask;\r
    CacheTag  = &DiskCache->CacheTag[GroupNo];\r
    if (CacheTag->RealSize > 0 && CacheTag->PageNo == PageNo) {\r
      //\r
      // When reading data form disk directly, if some dirty data\r
      // in cache is in this rang, this data in the Buffer need to\r
      // be updated with the cache's dirty data.\r
      //\r
      if (IoMode == ReadDisk) {\r
        if (CacheTag->Dirty) {\r
          CopyMem (\r
            Buffer + ((PageNo - StartPageNo) << PageAlignment),\r
            BaseAddress + (GroupNo << PageAlignment),\r
            PageSize\r
            );\r
        }\r
      } else {\r
        //\r
        // Make all valid entries in this range invalid.\r
        //\r
        CacheTag->RealSize = 0;\r
      }\r
    }\r
  }\r
}\r
\r
/**\r
\r
  Exchange the cache page with the image on the disk\r
\r
  @param  Volume                - FAT file system volume.\r
  @param  DataType              - Indicate the cache type.\r
  @param  IoMode                - Indicate whether to load this page from disk or store this page to disk.\r
  @param  CacheTag              - The Cache Tag for the current cache page.\r
  @param  Task                    point to task instance.\r
\r
  @retval EFI_SUCCESS           - Cache page exchanged successfully.\r
  @return Others                - An error occurred when exchanging cache page.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
FatExchangeCachePage (\r
  IN FAT_VOLUME         *Volume,\r
  IN CACHE_DATA_TYPE    DataType,\r
  IN IO_MODE            IoMode,\r
  IN CACHE_TAG          *CacheTag,\r
  IN FAT_TASK           *Task\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       GroupNo;\r
  UINTN       PageNo;\r
  UINTN       WriteCount;\r
  UINTN       RealSize;\r
  UINT64      EntryPos;\r
  UINT64      MaxSize;\r
  DISK_CACHE  *DiskCache;\r
  VOID        *PageAddress;\r
  UINT8       PageAlignment;\r
\r
  DiskCache     = &Volume->DiskCache[DataType];\r
  PageNo        = CacheTag->PageNo;\r
  GroupNo       = PageNo & DiskCache->GroupMask;\r
  PageAlignment = DiskCache->PageAlignment;\r
  PageAddress   = DiskCache->CacheBase + (GroupNo << PageAlignment);\r
  EntryPos      = DiskCache->BaseAddress + LShiftU64 (PageNo, PageAlignment);\r
  RealSize      = CacheTag->RealSize;\r
  if (IoMode == ReadDisk) {\r
    RealSize  = (UINTN)1 << PageAlignment;\r
    MaxSize   = DiskCache->LimitAddress - EntryPos;\r
    if (MaxSize < RealSize) {\r
      DEBUG ((EFI_D_INFO, "FatDiskIo: Cache Page OutBound occurred! \n"));\r
      RealSize = (UINTN) MaxSize;\r
    }\r
  }\r
\r
  WriteCount = 1;\r
  if (DataType == CacheFat && IoMode == WriteDisk) {\r
    WriteCount = Volume->NumFats;\r
  }\r
\r
  do {\r
    //\r
    // Only fat table writing will execute more than once\r
    //\r
    Status = FatDiskIo (Volume, IoMode, EntryPos, RealSize, PageAddress, Task);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    EntryPos += Volume->FatSize;\r
  } while (--WriteCount > 0);\r
\r
  CacheTag->Dirty     = FALSE;\r
  CacheTag->RealSize  = RealSize;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
\r
  Get one cache page by specified PageNo.\r
\r
  @param  Volume                - FAT file system volume.\r
  @param  CacheDataType         - The cache type: CACHE_FAT or CACHE_DATA.\r
  @param  PageNo                - PageNo to match with the cache.\r
  @param  CacheTag              - The Cache Tag for the current cache page.\r
\r
  @retval EFI_SUCCESS           - Get the cache page successfully.\r
  @return other                 - An error occurred when accessing data.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
FatGetCachePage (\r
  IN FAT_VOLUME         *Volume,\r
  IN CACHE_DATA_TYPE    CacheDataType,\r
  IN UINTN              PageNo,\r
  IN CACHE_TAG          *CacheTag\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       OldPageNo;\r
\r
  OldPageNo = CacheTag->PageNo;\r
  if (CacheTag->RealSize > 0 && OldPageNo == PageNo) {\r
    //\r
    // Cache Hit occurred\r
    //\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // Write dirty cache page back to disk\r
  //\r
  if (CacheTag->RealSize > 0 && CacheTag->Dirty) {\r
    Status = FatExchangeCachePage (Volume, CacheDataType, WriteDisk, CacheTag, NULL);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
  //\r
  // Load new data from disk;\r
  //\r
  CacheTag->PageNo  = PageNo;\r
  Status            = FatExchangeCachePage (Volume, CacheDataType, ReadDisk, CacheTag, NULL);\r
\r
  return Status;\r
}\r
\r
/**\r
\r
  Read Length bytes from the position of Offset into Buffer, or\r
  write Length bytes from Buffer into the position of Offset.\r
\r
  @param  Volume                - FAT file system volume.\r
  @param  CacheDataType         - The type of cache: CACHE_DATA or CACHE_FAT.\r
  @param  IoMode                - Indicate the type of disk access.\r
  @param  PageNo                - The number of unaligned cache page.\r
  @param  Offset                - The starting byte of cache page.\r
  @param  Length                - The number of bytes that is read or written\r
  @param  Buffer                - Buffer containing cache data.\r
\r
  @retval EFI_SUCCESS           - The data was accessed correctly.\r
  @return Others                - An error occurred when accessing unaligned cache page.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
FatAccessUnalignedCachePage (\r
  IN     FAT_VOLUME        *Volume,\r
  IN     CACHE_DATA_TYPE   CacheDataType,\r
  IN     IO_MODE           IoMode,\r
  IN     UINTN             PageNo,\r
  IN     UINTN             Offset,\r
  IN     UINTN             Length,\r
  IN OUT VOID              *Buffer\r
  )\r
{\r
  EFI_STATUS  Status;\r
  VOID        *Source;\r
  VOID        *Destination;\r
  DISK_CACHE  *DiskCache;\r
  CACHE_TAG   *CacheTag;\r
  UINTN       GroupNo;\r
\r
  DiskCache = &Volume->DiskCache[CacheDataType];\r
  GroupNo   = PageNo & DiskCache->GroupMask;\r
  CacheTag  = &DiskCache->CacheTag[GroupNo];\r
  Status    = FatGetCachePage (Volume, CacheDataType, PageNo, CacheTag);\r
  if (!EFI_ERROR (Status)) {\r
    Source      = DiskCache->CacheBase + (GroupNo << DiskCache->PageAlignment) + Offset;\r
    Destination = Buffer;\r
    if (IoMode != ReadDisk) {\r
      CacheTag->Dirty   = TRUE;\r
      DiskCache->Dirty  = TRUE;\r
      Destination       = Source;\r
      Source            = Buffer;\r
    }\r
\r
    CopyMem (Destination, Source, Length);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
\r
  Read BufferSize bytes from the position of Offset into Buffer,\r
  or write BufferSize bytes from Buffer into the position of Offset.\r
\r
  Base on the parameter of CACHE_DATA_TYPE, the data access will be divided into\r
  the access of FAT cache (CACHE_FAT) and the access of Data cache (CACHE_DATA):\r
\r
  1. Access of FAT cache (CACHE_FAT): Access the data in the FAT cache, if there is cache\r
     page hit, just return the cache page; else update the related cache page and return\r
     the right cache page.\r
  2. Access of Data cache (CACHE_DATA):\r
     The access data will be divided into UnderRun data, Aligned data and OverRun data;\r
     The UnderRun data and OverRun data will be accessed by the Data cache,\r
     but the Aligned data will be accessed with disk directly.\r
\r
  @param  Volume                - FAT file system volume.\r
  @param  CacheDataType         - The type of cache: CACHE_DATA or CACHE_FAT.\r
  @param  IoMode                - Indicate the type of disk access.\r
  @param  Offset                - The starting byte offset to read from.\r
  @param  BufferSize            - Size of Buffer.\r
  @param  Buffer                - Buffer containing cache data.\r
  @param  Task                    point to task instance.\r
\r
  @retval EFI_SUCCESS           - The data was accessed correctly.\r
  @retval EFI_MEDIA_CHANGED     - The MediaId does not match the current device.\r
  @return Others                - An error occurred when accessing cache.\r
\r
**/\r
EFI_STATUS\r
FatAccessCache (\r
  IN     FAT_VOLUME         *Volume,\r
  IN     CACHE_DATA_TYPE    CacheDataType,\r
  IN     IO_MODE            IoMode,\r
  IN     UINT64             Offset,\r
  IN     UINTN              BufferSize,\r
  IN OUT UINT8              *Buffer,\r
  IN     FAT_TASK           *Task\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       PageSize;\r
  UINTN       UnderRun;\r
  UINTN       OverRun;\r
  UINTN       AlignedSize;\r
  UINTN       Length;\r
  UINTN       PageNo;\r
  UINTN       AlignedPageCount;\r
  UINTN       OverRunPageNo;\r
  DISK_CACHE  *DiskCache;\r
  UINT64      EntryPos;\r
  UINT8       PageAlignment;\r
\r
  ASSERT (Volume->CacheBuffer != NULL);\r
\r
  Status        = EFI_SUCCESS;\r
  DiskCache     = &Volume->DiskCache[CacheDataType];\r
  EntryPos      = Offset - DiskCache->BaseAddress;\r
  PageAlignment = DiskCache->PageAlignment;\r
  PageSize      = (UINTN)1 << PageAlignment;\r
  PageNo        = (UINTN) RShiftU64 (EntryPos, PageAlignment);\r
  UnderRun      = ((UINTN) EntryPos) & (PageSize - 1);\r
\r
  if (UnderRun > 0) {\r
    Length = PageSize - UnderRun;\r
    if (Length > BufferSize) {\r
      Length = BufferSize;\r
    }\r
\r
    Status = FatAccessUnalignedCachePage (Volume, CacheDataType, IoMode, PageNo, UnderRun, Length, Buffer);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    Buffer     += Length;\r
    BufferSize -= Length;\r
    PageNo++;\r
  }\r
\r
  AlignedPageCount  = BufferSize >> PageAlignment;\r
  OverRunPageNo     = PageNo + AlignedPageCount;\r
  //\r
  // The access of the Aligned data\r
  //\r
  if (AlignedPageCount > 0) {\r
    //\r
    // Accessing fat table cannot have alignment data\r
    //\r
    ASSERT (CacheDataType == CacheData);\r
\r
    EntryPos    = Volume->RootPos + LShiftU64 (PageNo, PageAlignment);\r
    AlignedSize = AlignedPageCount << PageAlignment;\r
    Status      = FatDiskIo (Volume, IoMode, EntryPos, AlignedSize, Buffer, Task);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
    //\r
    // If these access data over laps the relative cache range, these cache pages need\r
    // to be updated.\r
    //\r
    FatFlushDataCacheRange (Volume, IoMode, PageNo, OverRunPageNo, Buffer);\r
    Buffer      += AlignedSize;\r
    BufferSize  -= AlignedSize;\r
  }\r
  //\r
  // The access of the OverRun data\r
  //\r
  OverRun = BufferSize;\r
  if (OverRun > 0) {\r
    //\r
    // Last read is not a complete page\r
    //\r
    Status = FatAccessUnalignedCachePage (Volume, CacheDataType, IoMode, OverRunPageNo, 0, OverRun, Buffer);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
\r
  Flush all the dirty cache back, include the FAT cache and the Data cache.\r
\r
  @param  Volume                - FAT file system volume.\r
  @param  Task                    point to task instance.\r
\r
  @retval EFI_SUCCESS           - Flush all the dirty cache back successfully\r
  @return other                 - An error occurred when writing the data into the disk\r
\r
**/\r
EFI_STATUS\r
FatVolumeFlushCache (\r
  IN FAT_VOLUME         *Volume,\r
  IN FAT_TASK           *Task\r
  )\r
{\r
  EFI_STATUS      Status;\r
  CACHE_DATA_TYPE CacheDataType;\r
  UINTN           GroupIndex;\r
  UINTN           GroupMask;\r
  DISK_CACHE      *DiskCache;\r
  CACHE_TAG       *CacheTag;\r
\r
  for (CacheDataType = (CACHE_DATA_TYPE) 0; CacheDataType < CacheMaxType; CacheDataType++) {\r
    DiskCache = &Volume->DiskCache[CacheDataType];\r
    if (DiskCache->Dirty) {\r
      //\r
      // Data cache or fat cache is dirty, write the dirty data back\r
      //\r
      GroupMask = DiskCache->GroupMask;\r
      for (GroupIndex = 0; GroupIndex <= GroupMask; GroupIndex++) {\r
        CacheTag = &DiskCache->CacheTag[GroupIndex];\r
        if (CacheTag->RealSize > 0 && CacheTag->Dirty) {\r
          //\r
          // Write back all Dirty Data Cache Page to disk\r
          //\r
          Status = FatExchangeCachePage (Volume, CacheDataType, WriteDisk, CacheTag, Task);\r
          if (EFI_ERROR (Status)) {\r
            return Status;\r
          }\r
        }\r
      }\r
\r
      DiskCache->Dirty = FALSE;\r
    }\r
  }\r
  //\r
  // Flush the block device.\r
  //\r
  Status = Volume->BlockIo->FlushBlocks (Volume->BlockIo);\r
  return Status;\r
}\r
\r
/**\r
\r
  Initialize the disk cache according to Volume's FatType.\r
\r
  @param  Volume                - FAT file system volume.\r
\r
  @retval EFI_SUCCESS           - The disk cache is successfully initialized.\r
  @retval EFI_OUT_OF_RESOURCES  - Not enough memory to allocate disk cache.\r
\r
**/\r
EFI_STATUS\r
FatInitializeDiskCache (\r
  IN FAT_VOLUME         *Volume\r
  )\r
{\r
  DISK_CACHE  *DiskCache;\r
  UINTN       FatCacheGroupCount;\r
  UINTN       DataCacheSize;\r
  UINTN       FatCacheSize;\r
  UINT8       *CacheBuffer;\r
\r
  DiskCache = Volume->DiskCache;\r
  //\r
  // Configure the parameters of disk cache\r
  //\r
  if (Volume->FatType == Fat12) {\r
    FatCacheGroupCount                  = FAT_FATCACHE_GROUP_MIN_COUNT;\r
    DiskCache[CacheFat].PageAlignment  = FAT_FATCACHE_PAGE_MIN_ALIGNMENT;\r
    DiskCache[CacheData].PageAlignment = FAT_DATACACHE_PAGE_MIN_ALIGNMENT;\r
  } else {\r
    FatCacheGroupCount                  = FAT_FATCACHE_GROUP_MAX_COUNT;\r
    DiskCache[CacheFat].PageAlignment  = FAT_FATCACHE_PAGE_MAX_ALIGNMENT;\r
    DiskCache[CacheData].PageAlignment = FAT_DATACACHE_PAGE_MAX_ALIGNMENT;\r
  }\r
\r
  DiskCache[CacheData].GroupMask     = FAT_DATACACHE_GROUP_COUNT - 1;\r
  DiskCache[CacheData].BaseAddress   = Volume->RootPos;\r
  DiskCache[CacheData].LimitAddress  = Volume->VolumeSize;\r
  DiskCache[CacheFat].GroupMask      = FatCacheGroupCount - 1;\r
  DiskCache[CacheFat].BaseAddress    = Volume->FatPos;\r
  DiskCache[CacheFat].LimitAddress   = Volume->FatPos + Volume->FatSize;\r
  FatCacheSize                        = FatCacheGroupCount << DiskCache[CacheFat].PageAlignment;\r
  DataCacheSize                       = FAT_DATACACHE_GROUP_COUNT << DiskCache[CacheData].PageAlignment;\r
  //\r
  // Allocate the Fat Cache buffer\r
  //\r
  CacheBuffer = AllocateZeroPool (FatCacheSize + DataCacheSize);\r
  if (CacheBuffer == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Volume->CacheBuffer             = CacheBuffer;\r
  DiskCache[CacheFat].CacheBase  = CacheBuffer;\r
  DiskCache[CacheData].CacheBase = CacheBuffer + FatCacheSize;\r
  return EFI_SUCCESS;\r
}\r
Commit	Line	Data
	1	/** @file\r
	2	Cache implementation for EFI FAT File system driver.\r
	3	\r
	4	Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>\r
	5	This program and the accompanying materials are licensed and made available\r
	6	under the terms and conditions of the BSD License which accompanies this\r
	7	distribution. The full text of the license may be found at\r
	8	http://opensource.org/licenses/bsd-license.php\r
	9	\r
	10	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	11	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	12	\r
	13	**/\r
	14	\r
	15	#include "Fat.h"\r
	16	\r
	17	/**\r
	18	\r
	19	This function is used by the Data Cache.\r
	20	\r
	21	When this function is called by write command, all entries in this range\r
	22	are older than the contents in disk, so they are invalid; just mark them invalid.\r
	23	\r
	24	When this function is called by read command, if any entry in this range\r
	25	is dirty, it means that the relative info directly readed from media is older than\r
	26	than the info in the cache; So need to update the relative info in the Buffer.\r
	27	\r
	28	@param Volume - FAT file system volume.\r
	29	@param IoMode - This function is called by read command or write command\r
	30	@param StartPageNo - First PageNo to be checked in the cache.\r
	31	@param EndPageNo - Last PageNo to be checked in the cache.\r
	32	@param Buffer - The user buffer need to update. Only when doing the read command\r
	33	and there is dirty cache in the cache range, this parameter will be used.\r
	34	\r
	35	**/\r
	36	STATIC\r
	37	VOID\r
	38	FatFlushDataCacheRange (\r
	39	IN FAT_VOLUME *Volume,\r
	40	IN IO_MODE IoMode,\r
	41	IN UINTN StartPageNo,\r
	42	IN UINTN EndPageNo,\r
	43	OUT UINT8 *Buffer\r
	44	)\r
	45	{\r
	46	UINTN PageNo;\r
	47	UINTN GroupNo;\r
	48	UINTN GroupMask;\r
	49	UINTN PageSize;\r
	50	UINT8 PageAlignment;\r
	51	DISK_CACHE *DiskCache;\r
	52	CACHE_TAG *CacheTag;\r
	53	UINT8 *BaseAddress;\r
	54	\r
	55	DiskCache = &Volume->DiskCache[CacheData];\r
	56	BaseAddress = DiskCache->CacheBase;\r
	57	GroupMask = DiskCache->GroupMask;\r
	58	PageAlignment = DiskCache->PageAlignment;\r
	59	PageSize = (UINTN)1 << PageAlignment;\r
	60	\r
	61	for (PageNo = StartPageNo; PageNo < EndPageNo; PageNo++) {\r
	62	GroupNo = PageNo & GroupMask;\r
	63	CacheTag = &DiskCache->CacheTag[GroupNo];\r
	64	if (CacheTag->RealSize > 0 && CacheTag->PageNo == PageNo) {\r
	65	//\r
	66	// When reading data form disk directly, if some dirty data\r
	67	// in cache is in this rang, this data in the Buffer need to\r
	68	// be updated with the cache's dirty data.\r
	69	//\r
	70	if (IoMode == ReadDisk) {\r
	71	if (CacheTag->Dirty) {\r
	72	CopyMem (\r
	73	Buffer + ((PageNo - StartPageNo) << PageAlignment),\r
	74	BaseAddress + (GroupNo << PageAlignment),\r
	75	PageSize\r
	76	);\r
	77	}\r
	78	} else {\r
	79	//\r
	80	// Make all valid entries in this range invalid.\r
	81	//\r
	82	CacheTag->RealSize = 0;\r
	83	}\r
	84	}\r
	85	}\r
	86	}\r
	87	\r
	88	/**\r
	89	\r
	90	Exchange the cache page with the image on the disk\r
	91	\r
	92	@param Volume - FAT file system volume.\r
	93	@param DataType - Indicate the cache type.\r
	94	@param IoMode - Indicate whether to load this page from disk or store this page to disk.\r
	95	@param CacheTag - The Cache Tag for the current cache page.\r
	96	@param Task point to task instance.\r
	97	\r
	98	@retval EFI_SUCCESS - Cache page exchanged successfully.\r
	99	@return Others - An error occurred when exchanging cache page.\r
	100	\r
	101	**/\r
	102	STATIC\r
	103	EFI_STATUS\r
	104	FatExchangeCachePage (\r
	105	IN FAT_VOLUME *Volume,\r
	106	IN CACHE_DATA_TYPE DataType,\r
	107	IN IO_MODE IoMode,\r
	108	IN CACHE_TAG *CacheTag,\r
	109	IN FAT_TASK *Task\r
	110	)\r
	111	{\r
	112	EFI_STATUS Status;\r
	113	UINTN GroupNo;\r
	114	UINTN PageNo;\r
	115	UINTN WriteCount;\r
	116	UINTN RealSize;\r
	117	UINT64 EntryPos;\r
	118	UINT64 MaxSize;\r
	119	DISK_CACHE *DiskCache;\r
	120	VOID *PageAddress;\r
	121	UINT8 PageAlignment;\r
	122	\r
	123	DiskCache = &Volume->DiskCache[DataType];\r
	124	PageNo = CacheTag->PageNo;\r
	125	GroupNo = PageNo & DiskCache->GroupMask;\r
	126	PageAlignment = DiskCache->PageAlignment;\r
	127	PageAddress = DiskCache->CacheBase + (GroupNo << PageAlignment);\r
	128	EntryPos = DiskCache->BaseAddress + LShiftU64 (PageNo, PageAlignment);\r
	129	RealSize = CacheTag->RealSize;\r
	130	if (IoMode == ReadDisk) {\r
	131	RealSize = (UINTN)1 << PageAlignment;\r
	132	MaxSize = DiskCache->LimitAddress - EntryPos;\r
	133	if (MaxSize < RealSize) {\r
	134	DEBUG ((EFI_D_INFO, "FatDiskIo: Cache Page OutBound occurred! \n"));\r
	135	RealSize = (UINTN) MaxSize;\r
	136	}\r
	137	}\r
	138	\r
	139	WriteCount = 1;\r
	140	if (DataType == CacheFat && IoMode == WriteDisk) {\r
	141	WriteCount = Volume->NumFats;\r
	142	}\r
	143	\r
	144	do {\r
	145	//\r
	146	// Only fat table writing will execute more than once\r
	147	//\r
	148	Status = FatDiskIo (Volume, IoMode, EntryPos, RealSize, PageAddress, Task);\r
	149	if (EFI_ERROR (Status)) {\r
	150	return Status;\r
	151	}\r
	152	\r
	153	EntryPos += Volume->FatSize;\r
	154	} while (--WriteCount > 0);\r
	155	\r
	156	CacheTag->Dirty = FALSE;\r
	157	CacheTag->RealSize = RealSize;\r
	158	return EFI_SUCCESS;\r
	159	}\r
	160	\r
	161	/**\r
	162	\r
	163	Get one cache page by specified PageNo.\r
	164	\r
	165	@param Volume - FAT file system volume.\r
	166	@param CacheDataType - The cache type: CACHE_FAT or CACHE_DATA.\r
	167	@param PageNo - PageNo to match with the cache.\r
	168	@param CacheTag - The Cache Tag for the current cache page.\r
	169	\r
	170	@retval EFI_SUCCESS - Get the cache page successfully.\r
	171	@return other - An error occurred when accessing data.\r
	172	\r
	173	**/\r
	174	STATIC\r
	175	EFI_STATUS\r
	176	FatGetCachePage (\r
	177	IN FAT_VOLUME *Volume,\r
	178	IN CACHE_DATA_TYPE CacheDataType,\r
	179	IN UINTN PageNo,\r
	180	IN CACHE_TAG *CacheTag\r
	181	)\r
	182	{\r
	183	EFI_STATUS Status;\r
	184	UINTN OldPageNo;\r
	185	\r
	186	OldPageNo = CacheTag->PageNo;\r
	187	if (CacheTag->RealSize > 0 && OldPageNo == PageNo) {\r
	188	//\r
	189	// Cache Hit occurred\r
	190	//\r
	191	return EFI_SUCCESS;\r
	192	}\r
	193	\r
	194	//\r
	195	// Write dirty cache page back to disk\r
	196	//\r
	197	if (CacheTag->RealSize > 0 && CacheTag->Dirty) {\r
	198	Status = FatExchangeCachePage (Volume, CacheDataType, WriteDisk, CacheTag, NULL);\r
	199	if (EFI_ERROR (Status)) {\r
	200	return Status;\r
	201	}\r
	202	}\r
	203	//\r
	204	// Load new data from disk;\r
	205	//\r
	206	CacheTag->PageNo = PageNo;\r
	207	Status = FatExchangeCachePage (Volume, CacheDataType, ReadDisk, CacheTag, NULL);\r
	208	\r
	209	return Status;\r
	210	}\r
	211	\r
	212	/**\r
	213	\r
	214	Read Length bytes from the position of Offset into Buffer, or\r
	215	write Length bytes from Buffer into the position of Offset.\r
	216	\r
	217	@param Volume - FAT file system volume.\r
	218	@param CacheDataType - The type of cache: CACHE_DATA or CACHE_FAT.\r
	219	@param IoMode - Indicate the type of disk access.\r
	220	@param PageNo - The number of unaligned cache page.\r
	221	@param Offset - The starting byte of cache page.\r
	222	@param Length - The number of bytes that is read or written\r
	223	@param Buffer - Buffer containing cache data.\r
	224	\r
	225	@retval EFI_SUCCESS - The data was accessed correctly.\r
	226	@return Others - An error occurred when accessing unaligned cache page.\r
	227	\r
	228	**/\r
	229	STATIC\r
	230	EFI_STATUS\r
	231	FatAccessUnalignedCachePage (\r
	232	IN FAT_VOLUME *Volume,\r
	233	IN CACHE_DATA_TYPE CacheDataType,\r
	234	IN IO_MODE IoMode,\r
	235	IN UINTN PageNo,\r
	236	IN UINTN Offset,\r
	237	IN UINTN Length,\r
	238	IN OUT VOID *Buffer\r
	239	)\r
	240	{\r
	241	EFI_STATUS Status;\r
	242	VOID *Source;\r
	243	VOID *Destination;\r
	244	DISK_CACHE *DiskCache;\r
	245	CACHE_TAG *CacheTag;\r
	246	UINTN GroupNo;\r
	247	\r
	248	DiskCache = &Volume->DiskCache[CacheDataType];\r
	249	GroupNo = PageNo & DiskCache->GroupMask;\r
	250	CacheTag = &DiskCache->CacheTag[GroupNo];\r
	251	Status = FatGetCachePage (Volume, CacheDataType, PageNo, CacheTag);\r
	252	if (!EFI_ERROR (Status)) {\r
	253	Source = DiskCache->CacheBase + (GroupNo << DiskCache->PageAlignment) + Offset;\r
	254	Destination = Buffer;\r
	255	if (IoMode != ReadDisk) {\r
	256	CacheTag->Dirty = TRUE;\r
	257	DiskCache->Dirty = TRUE;\r
	258	Destination = Source;\r
	259	Source = Buffer;\r
	260	}\r
	261	\r
	262	CopyMem (Destination, Source, Length);\r
	263	}\r
	264	\r
	265	return Status;\r
	266	}\r
	267	\r
	268	/**\r
	269	\r
	270	Read BufferSize bytes from the position of Offset into Buffer,\r
	271	or write BufferSize bytes from Buffer into the position of Offset.\r
	272	\r
	273	Base on the parameter of CACHE_DATA_TYPE, the data access will be divided into\r
	274	the access of FAT cache (CACHE_FAT) and the access of Data cache (CACHE_DATA):\r
	275	\r
	276	1. Access of FAT cache (CACHE_FAT): Access the data in the FAT cache, if there is cache\r
	277	page hit, just return the cache page; else update the related cache page and return\r
	278	the right cache page.\r
	279	2. Access of Data cache (CACHE_DATA):\r
	280	The access data will be divided into UnderRun data, Aligned data and OverRun data;\r
	281	The UnderRun data and OverRun data will be accessed by the Data cache,\r
	282	but the Aligned data will be accessed with disk directly.\r
	283	\r
	284	@param Volume - FAT file system volume.\r
	285	@param CacheDataType - The type of cache: CACHE_DATA or CACHE_FAT.\r
	286	@param IoMode - Indicate the type of disk access.\r
	287	@param Offset - The starting byte offset to read from.\r
	288	@param BufferSize - Size of Buffer.\r
	289	@param Buffer - Buffer containing cache data.\r
	290	@param Task point to task instance.\r
	291	\r
	292	@retval EFI_SUCCESS - The data was accessed correctly.\r
	293	@retval EFI_MEDIA_CHANGED - The MediaId does not match the current device.\r
	294	@return Others - An error occurred when accessing cache.\r
	295	\r
	296	**/\r
	297	EFI_STATUS\r
	298	FatAccessCache (\r
	299	IN FAT_VOLUME *Volume,\r
	300	IN CACHE_DATA_TYPE CacheDataType,\r
	301	IN IO_MODE IoMode,\r
	302	IN UINT64 Offset,\r
	303	IN UINTN BufferSize,\r
	304	IN OUT UINT8 *Buffer,\r
	305	IN FAT_TASK *Task\r
	306	)\r
	307	{\r
	308	EFI_STATUS Status;\r
	309	UINTN PageSize;\r
	310	UINTN UnderRun;\r
	311	UINTN OverRun;\r
	312	UINTN AlignedSize;\r
	313	UINTN Length;\r
	314	UINTN PageNo;\r
	315	UINTN AlignedPageCount;\r
	316	UINTN OverRunPageNo;\r
	317	DISK_CACHE *DiskCache;\r
	318	UINT64 EntryPos;\r
	319	UINT8 PageAlignment;\r
	320	\r
	321	ASSERT (Volume->CacheBuffer != NULL);\r
	322	\r
	323	Status = EFI_SUCCESS;\r
	324	DiskCache = &Volume->DiskCache[CacheDataType];\r
	325	EntryPos = Offset - DiskCache->BaseAddress;\r
	326	PageAlignment = DiskCache->PageAlignment;\r
	327	PageSize = (UINTN)1 << PageAlignment;\r
	328	PageNo = (UINTN) RShiftU64 (EntryPos, PageAlignment);\r
	329	UnderRun = ((UINTN) EntryPos) & (PageSize - 1);\r
	330	\r
	331	if (UnderRun > 0) {\r
	332	Length = PageSize - UnderRun;\r
	333	if (Length > BufferSize) {\r
	334	Length = BufferSize;\r
	335	}\r
	336	\r
	337	Status = FatAccessUnalignedCachePage (Volume, CacheDataType, IoMode, PageNo, UnderRun, Length, Buffer);\r
	338	if (EFI_ERROR (Status)) {\r
	339	return Status;\r
	340	}\r
	341	\r
	342	Buffer += Length;\r
	343	BufferSize -= Length;\r
	344	PageNo++;\r
	345	}\r
	346	\r
	347	AlignedPageCount = BufferSize >> PageAlignment;\r
	348	OverRunPageNo = PageNo + AlignedPageCount;\r
	349	//\r
	350	// The access of the Aligned data\r
	351	//\r
	352	if (AlignedPageCount > 0) {\r
	353	//\r
	354	// Accessing fat table cannot have alignment data\r
	355	//\r
	356	ASSERT (CacheDataType == CacheData);\r
	357	\r
	358	EntryPos = Volume->RootPos + LShiftU64 (PageNo, PageAlignment);\r
	359	AlignedSize = AlignedPageCount << PageAlignment;\r
	360	Status = FatDiskIo (Volume, IoMode, EntryPos, AlignedSize, Buffer, Task);\r
	361	if (EFI_ERROR (Status)) {\r
	362	return Status;\r
	363	}\r
	364	//\r
	365	// If these access data over laps the relative cache range, these cache pages need\r
	366	// to be updated.\r
	367	//\r
	368	FatFlushDataCacheRange (Volume, IoMode, PageNo, OverRunPageNo, Buffer);\r
	369	Buffer += AlignedSize;\r
	370	BufferSize -= AlignedSize;\r
	371	}\r
	372	//\r
	373	// The access of the OverRun data\r
	374	//\r
	375	OverRun = BufferSize;\r
	376	if (OverRun > 0) {\r
	377	//\r
	378	// Last read is not a complete page\r
	379	//\r
	380	Status = FatAccessUnalignedCachePage (Volume, CacheDataType, IoMode, OverRunPageNo, 0, OverRun, Buffer);\r
	381	}\r
	382	\r
	383	return Status;\r
	384	}\r
	385	\r
	386	/**\r
	387	\r
	388	Flush all the dirty cache back, include the FAT cache and the Data cache.\r
	389	\r
	390	@param Volume - FAT file system volume.\r
	391	@param Task point to task instance.\r
	392	\r
	393	@retval EFI_SUCCESS - Flush all the dirty cache back successfully\r
	394	@return other - An error occurred when writing the data into the disk\r
	395	\r
	396	**/\r
	397	EFI_STATUS\r
	398	FatVolumeFlushCache (\r
	399	IN FAT_VOLUME *Volume,\r
	400	IN FAT_TASK *Task\r
	401	)\r
	402	{\r
	403	EFI_STATUS Status;\r
	404	CACHE_DATA_TYPE CacheDataType;\r
	405	UINTN GroupIndex;\r
	406	UINTN GroupMask;\r
	407	DISK_CACHE *DiskCache;\r
	408	CACHE_TAG *CacheTag;\r
	409	\r
	410	for (CacheDataType = (CACHE_DATA_TYPE) 0; CacheDataType < CacheMaxType; CacheDataType++) {\r
	411	DiskCache = &Volume->DiskCache[CacheDataType];\r
	412	if (DiskCache->Dirty) {\r
	413	//\r
	414	// Data cache or fat cache is dirty, write the dirty data back\r
	415	//\r
	416	GroupMask = DiskCache->GroupMask;\r
	417	for (GroupIndex = 0; GroupIndex <= GroupMask; GroupIndex++) {\r
	418	CacheTag = &DiskCache->CacheTag[GroupIndex];\r
	419	if (CacheTag->RealSize > 0 && CacheTag->Dirty) {\r
	420	//\r
	421	// Write back all Dirty Data Cache Page to disk\r
	422	//\r
	423	Status = FatExchangeCachePage (Volume, CacheDataType, WriteDisk, CacheTag, Task);\r
	424	if (EFI_ERROR (Status)) {\r
	425	return Status;\r
	426	}\r
	427	}\r
	428	}\r
	429	\r
	430	DiskCache->Dirty = FALSE;\r
	431	}\r
	432	}\r
	433	//\r
	434	// Flush the block device.\r
	435	//\r
	436	Status = Volume->BlockIo->FlushBlocks (Volume->BlockIo);\r
	437	return Status;\r
	438	}\r
	439	\r
	440	/**\r
	441	\r
	442	Initialize the disk cache according to Volume's FatType.\r
	443	\r
	444	@param Volume - FAT file system volume.\r
	445	\r
	446	@retval EFI_SUCCESS - The disk cache is successfully initialized.\r
	447	@retval EFI_OUT_OF_RESOURCES - Not enough memory to allocate disk cache.\r
	448	\r
	449	**/\r
	450	EFI_STATUS\r
	451	FatInitializeDiskCache (\r
	452	IN FAT_VOLUME *Volume\r
	453	)\r
	454	{\r
	455	DISK_CACHE *DiskCache;\r
	456	UINTN FatCacheGroupCount;\r
	457	UINTN DataCacheSize;\r
	458	UINTN FatCacheSize;\r
	459	UINT8 *CacheBuffer;\r
	460	\r
	461	DiskCache = Volume->DiskCache;\r
	462	//\r
	463	// Configure the parameters of disk cache\r
	464	//\r
	465	if (Volume->FatType == Fat12) {\r
	466	FatCacheGroupCount = FAT_FATCACHE_GROUP_MIN_COUNT;\r
	467	DiskCache[CacheFat].PageAlignment = FAT_FATCACHE_PAGE_MIN_ALIGNMENT;\r
	468	DiskCache[CacheData].PageAlignment = FAT_DATACACHE_PAGE_MIN_ALIGNMENT;\r
	469	} else {\r
	470	FatCacheGroupCount = FAT_FATCACHE_GROUP_MAX_COUNT;\r
	471	DiskCache[CacheFat].PageAlignment = FAT_FATCACHE_PAGE_MAX_ALIGNMENT;\r
	472	DiskCache[CacheData].PageAlignment = FAT_DATACACHE_PAGE_MAX_ALIGNMENT;\r
	473	}\r
	474	\r
	475	DiskCache[CacheData].GroupMask = FAT_DATACACHE_GROUP_COUNT - 1;\r
	476	DiskCache[CacheData].BaseAddress = Volume->RootPos;\r
	477	DiskCache[CacheData].LimitAddress = Volume->VolumeSize;\r
	478	DiskCache[CacheFat].GroupMask = FatCacheGroupCount - 1;\r
	479	DiskCache[CacheFat].BaseAddress = Volume->FatPos;\r
	480	DiskCache[CacheFat].LimitAddress = Volume->FatPos + Volume->FatSize;\r
	481	FatCacheSize = FatCacheGroupCount << DiskCache[CacheFat].PageAlignment;\r
	482	DataCacheSize = FAT_DATACACHE_GROUP_COUNT << DiskCache[CacheData].PageAlignment;\r
	483	//\r
	484	// Allocate the Fat Cache buffer\r
	485	//\r
	486	CacheBuffer = AllocateZeroPool (FatCacheSize + DataCacheSize);\r
	487	if (CacheBuffer == NULL) {\r
	488	return EFI_OUT_OF_RESOURCES;\r
	489	}\r
	490	\r
	491	Volume->CacheBuffer = CacheBuffer;\r
	492	DiskCache[CacheFat].CacheBase = CacheBuffer;\r
	493	DiskCache[CacheData].CacheBase = CacheBuffer + FatCacheSize;\r
	494	return EFI_SUCCESS;\r
	495	}\r