FatPkg: Clean up source files
[mirror_edk2.git] / FatPkg / FatPei / FatLiteLib.c
1 /** @file
2 General purpose supporting routines for FAT recovery PEIM
3
4 Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
5
6 This program and the accompanying materials are licensed and made available
7 under the terms and conditions of the BSD License which accompanies this
8 distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16 #include "FatLitePeim.h"
17
18
19 #define CHAR_FAT_VALID 0x01
20
21
22 /**
23 Converts a union code character to upper case.
24 This functions converts a unicode character to upper case.
25 If the input Letter is not a lower-cased letter,
26 the original value is returned.
27
28 @param Letter The input unicode character.
29
30 @return The upper cased letter.
31
32 **/
33 CHAR16
34 ToUpper (
35 IN CHAR16 Letter
36 )
37 {
38 if ('a' <= Letter && Letter <= 'z') {
39 Letter = (CHAR16) (Letter - 0x20);
40 }
41
42 return Letter;
43 }
44
45
46 /**
47 Reads a block of data from the block device by calling
48 underlying Block I/O service.
49
50 @param PrivateData Global memory map for accessing global variables
51 @param BlockDeviceNo The index for the block device number.
52 @param Lba The logic block address to read data from.
53 @param BufferSize The size of data in byte to read.
54 @param Buffer The buffer of the
55
56 @retval EFI_DEVICE_ERROR The specified block device number exceeds the maximum
57 device number.
58 @retval EFI_DEVICE_ERROR The maximum address has exceeded the maximum address
59 of the block device.
60
61 **/
62 EFI_STATUS
63 FatReadBlock (
64 IN PEI_FAT_PRIVATE_DATA *PrivateData,
65 IN UINTN BlockDeviceNo,
66 IN EFI_PEI_LBA Lba,
67 IN UINTN BufferSize,
68 OUT VOID *Buffer
69 )
70 {
71 EFI_STATUS Status;
72 PEI_FAT_BLOCK_DEVICE *BlockDev;
73
74 if (BlockDeviceNo > PEI_FAT_MAX_BLOCK_DEVICE - 1) {
75 return EFI_DEVICE_ERROR;
76 }
77
78 Status = EFI_SUCCESS;
79 BlockDev = &(PrivateData->BlockDevice[BlockDeviceNo]);
80
81 if (BufferSize > MultU64x32 (BlockDev->LastBlock - Lba + 1, BlockDev->BlockSize)) {
82 return EFI_DEVICE_ERROR;
83 }
84
85 if (!BlockDev->Logical) {
86 //
87 // Status = BlockDev->ReadFunc
88 // (PrivateData->PeiServices, BlockDev->PhysicalDevNo, Lba, BufferSize, Buffer);
89 //
90 if (BlockDev->BlockIo2 != NULL) {
91 Status = BlockDev->BlockIo2->ReadBlocks (
92 (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (),
93 BlockDev->BlockIo2,
94 BlockDev->PhysicalDevNo,
95 Lba,
96 BufferSize,
97 Buffer
98 );
99 } else {
100 Status = BlockDev->BlockIo->ReadBlocks (
101 (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (),
102 BlockDev->BlockIo,
103 BlockDev->PhysicalDevNo,
104 Lba,
105 BufferSize,
106 Buffer
107 );
108 }
109
110 } else {
111 Status = FatReadDisk (
112 PrivateData,
113 BlockDev->ParentDevNo,
114 BlockDev->StartingPos + MultU64x32 (Lba, BlockDev->BlockSize),
115 BufferSize,
116 Buffer
117 );
118 }
119
120 return Status;
121 }
122
123
124 /**
125 Find a cache block designated to specific Block device and Lba.
126 If not found, invalidate an oldest one and use it. (LRU cache)
127
128 @param PrivateData the global memory map.
129 @param BlockDeviceNo the Block device.
130 @param Lba the Logical Block Address
131 @param CachePtr Ptr to the starting address of the memory holding the
132 data;
133
134 @retval EFI_SUCCESS The function completed successfully.
135 @retval EFI_DEVICE_ERROR Something error while accessing media.
136
137 **/
138 EFI_STATUS
139 FatGetCacheBlock (
140 IN PEI_FAT_PRIVATE_DATA *PrivateData,
141 IN UINTN BlockDeviceNo,
142 IN UINT64 Lba,
143 OUT CHAR8 **CachePtr
144 )
145 {
146 EFI_STATUS Status;
147 PEI_FAT_CACHE_BUFFER *CacheBuffer;
148 INTN Index;
149 STATIC UINT8 Seed;
150
151 Status = EFI_SUCCESS;
152 CacheBuffer = NULL;
153
154 //
155 // go through existing cache buffers
156 //
157 for (Index = 0; Index < PEI_FAT_CACHE_SIZE; Index++) {
158 CacheBuffer = &(PrivateData->CacheBuffer[Index]);
159 if (CacheBuffer->Valid && CacheBuffer->BlockDeviceNo == BlockDeviceNo && CacheBuffer->Lba == Lba) {
160 break;
161 }
162 }
163
164 if (Index < PEI_FAT_CACHE_SIZE) {
165 *CachePtr = (CHAR8 *) CacheBuffer->Buffer;
166 return EFI_SUCCESS;
167 }
168 //
169 // We have to find an invalid cache buffer
170 //
171 for (Index = 0; Index < PEI_FAT_CACHE_SIZE; Index++) {
172 if (!PrivateData->CacheBuffer[Index].Valid) {
173 break;
174 }
175 }
176 //
177 // Use the cache buffer
178 //
179 if (Index == PEI_FAT_CACHE_SIZE) {
180 Index = (Seed++) % PEI_FAT_CACHE_SIZE;
181 }
182
183 //
184 // Current device ID should be less than maximum device ID.
185 //
186 if (BlockDeviceNo >= PEI_FAT_MAX_BLOCK_DEVICE) {
187 return EFI_DEVICE_ERROR;
188 }
189
190 CacheBuffer = &(PrivateData->CacheBuffer[Index]);
191
192 CacheBuffer->BlockDeviceNo = BlockDeviceNo;
193 CacheBuffer->Lba = Lba;
194 CacheBuffer->Size = PrivateData->BlockDevice[BlockDeviceNo].BlockSize;
195
196 //
197 // Read in the data
198 //
199 Status = FatReadBlock (
200 PrivateData,
201 BlockDeviceNo,
202 Lba,
203 CacheBuffer->Size,
204 CacheBuffer->Buffer
205 );
206 if (EFI_ERROR (Status)) {
207 return EFI_DEVICE_ERROR;
208 }
209
210 CacheBuffer->Valid = TRUE;
211 *CachePtr = (CHAR8 *) CacheBuffer->Buffer;
212
213 return Status;
214 }
215
216
217 /**
218 Disk reading.
219
220 @param PrivateData the global memory map;
221 @param BlockDeviceNo the block device to read;
222 @param StartingAddress the starting address.
223 @param Size the amount of data to read.
224 @param Buffer the buffer holding the data
225
226 @retval EFI_SUCCESS The function completed successfully.
227 @retval EFI_DEVICE_ERROR Something error.
228
229 **/
230 EFI_STATUS
231 FatReadDisk (
232 IN PEI_FAT_PRIVATE_DATA *PrivateData,
233 IN UINTN BlockDeviceNo,
234 IN UINT64 StartingAddress,
235 IN UINTN Size,
236 OUT VOID *Buffer
237 )
238 {
239 EFI_STATUS Status;
240 UINT32 BlockSize;
241 CHAR8 *BufferPtr;
242 CHAR8 *CachePtr;
243 UINT32 Offset;
244 UINT64 Lba;
245 UINT64 OverRunLba;
246 UINTN Amount;
247
248 Status = EFI_SUCCESS;
249 BufferPtr = Buffer;
250 BlockSize = PrivateData->BlockDevice[BlockDeviceNo].BlockSize;
251
252 //
253 // Read underrun
254 //
255 Lba = DivU64x32Remainder (StartingAddress, BlockSize, &Offset);
256 Status = FatGetCacheBlock (PrivateData, BlockDeviceNo, Lba, &CachePtr);
257 if (EFI_ERROR (Status)) {
258 return EFI_DEVICE_ERROR;
259 }
260
261 Amount = Size < (BlockSize - Offset) ? Size : (BlockSize - Offset);
262 CopyMem (BufferPtr, CachePtr + Offset, Amount);
263
264 if (Size == Amount) {
265 return EFI_SUCCESS;
266 }
267
268 Size -= Amount;
269 BufferPtr += Amount;
270 StartingAddress += Amount;
271 Lba += 1;
272
273 //
274 // Read aligned parts
275 //
276 OverRunLba = Lba + DivU64x32Remainder (Size, BlockSize, &Offset);
277
278 Size -= Offset;
279 Status = FatReadBlock (PrivateData, BlockDeviceNo, Lba, Size, BufferPtr);
280 if (EFI_ERROR (Status)) {
281 return EFI_DEVICE_ERROR;
282 }
283
284 BufferPtr += Size;
285
286 //
287 // Read overrun
288 //
289 if (Offset != 0) {
290 Status = FatGetCacheBlock (PrivateData, BlockDeviceNo, OverRunLba, &CachePtr);
291 if (EFI_ERROR (Status)) {
292 return EFI_DEVICE_ERROR;
293 }
294
295 CopyMem (BufferPtr, CachePtr, Offset);
296 }
297
298 return Status;
299 }
300
301
302 /**
303 This version is different from the version in Unicode collation
304 protocol in that this version strips off trailing blanks.
305 Converts an 8.3 FAT file name using an OEM character set
306 to a Null-terminated Unicode string.
307 Here does not expand DBCS FAT chars.
308
309 @param FatSize The size of the string Fat in bytes.
310 @param Fat A pointer to a Null-terminated string that contains
311 an 8.3 file name using an OEM character set.
312 @param Str A pointer to a Null-terminated Unicode string. The
313 string must be allocated in advance to hold FatSize
314 Unicode characters
315
316 **/
317 VOID
318 EngFatToStr (
319 IN UINTN FatSize,
320 IN CHAR8 *Fat,
321 OUT CHAR16 *Str
322 )
323 {
324 CHAR16 *String;
325
326 String = Str;
327 //
328 // No DBCS issues, just expand and add null terminate to end of string
329 //
330 while (*Fat != 0 && FatSize != 0) {
331 if (*Fat == ' ') {
332 break;
333 }
334 *String = *Fat;
335 String += 1;
336 Fat += 1;
337 FatSize -= 1;
338 }
339
340 *String = 0;
341 }
342
343
344 /**
345 Performs a case-insensitive comparison of two Null-terminated Unicode strings.
346
347 @param PrivateData Global memory map for accessing global variables
348 @param Str1 First string to perform case insensitive comparison.
349 @param Str2 Second string to perform case insensitive comparison.
350
351 **/
352 BOOLEAN
353 EngStriColl (
354 IN PEI_FAT_PRIVATE_DATA *PrivateData,
355 IN CHAR16 *Str1,
356 IN CHAR16 *Str2
357 )
358 {
359 CHAR16 UpperS1;
360 CHAR16 UpperS2;
361
362 UpperS1 = ToUpper (*Str1);
363 UpperS2 = ToUpper (*Str2);
364 while (*Str1 != 0) {
365 if (UpperS1 != UpperS2) {
366 return FALSE;
367 }
368
369 Str1++;
370 Str2++;
371 UpperS1 = ToUpper (*Str1);
372 UpperS2 = ToUpper (*Str2);
373 }
374
375 return (BOOLEAN) ((*Str2 != 0) ? FALSE : TRUE);
376 }