VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.c@ 102466

Last change on this file since 102466 was 99404, checked in by vboxsync, 23 months ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 14.8 KB
Line 
1/** @file
2 Fat File System driver routines that support EFI driver model.
3
4Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include "Fat.h"
10
11/**
12
13 Register Driver Binding protocol for this driver.
14
15 @param ImageHandle - Handle for the image of this driver.
16 @param SystemTable - Pointer to the EFI System Table.
17
18 @retval EFI_SUCCESS - Driver loaded.
19 @return other - Driver not loaded.
20
21**/
22EFI_STATUS
23EFIAPI
24FatEntryPoint (
25 IN EFI_HANDLE ImageHandle,
26 IN EFI_SYSTEM_TABLE *SystemTable
27 );
28
29/**
30
31 Unload function for this image. Uninstall DriverBinding protocol.
32
33 @param ImageHandle - Handle for the image of this driver.
34
35 @retval EFI_SUCCESS - Driver unloaded successfully.
36 @return other - Driver can not unloaded.
37
38**/
39EFI_STATUS
40EFIAPI
41FatUnload (
42 IN EFI_HANDLE ImageHandle
43 );
44
45/**
46
47 Test to see if this driver can add a file system to ControllerHandle.
48 ControllerHandle must support both Disk IO and Block IO protocols.
49
50 @param This - Protocol instance pointer.
51 @param ControllerHandle - Handle of device to test.
52 @param RemainingDevicePath - Not used.
53
54 @retval EFI_SUCCESS - This driver supports this device.
55 @retval EFI_ALREADY_STARTED - This driver is already running on this device.
56 @return other - This driver does not support this device.
57
58**/
59EFI_STATUS
60EFIAPI
61FatDriverBindingSupported (
62 IN EFI_DRIVER_BINDING_PROTOCOL *This,
63 IN EFI_HANDLE Controller,
64 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
65 );
66
67/**
68
69 Start this driver on ControllerHandle by opening a Block IO and Disk IO
70 protocol, reading Device Path. Add a Simple File System protocol to
71 ControllerHandle if the media contains a valid file system.
72
73 @param This - Protocol instance pointer.
74 @param ControllerHandle - Handle of device to bind driver to.
75 @param RemainingDevicePath - Not used.
76
77 @retval EFI_SUCCESS - This driver is added to DeviceHandle.
78 @retval EFI_ALREADY_STARTED - This driver is already running on DeviceHandle.
79 @retval EFI_OUT_OF_RESOURCES - Can not allocate the memory.
80 @return other - This driver does not support this device.
81
82**/
83EFI_STATUS
84EFIAPI
85FatDriverBindingStart (
86 IN EFI_DRIVER_BINDING_PROTOCOL *This,
87 IN EFI_HANDLE Controller,
88 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
89 );
90
91/**
92
93 Stop this driver on ControllerHandle.
94
95 @param This - Protocol instance pointer.
96 @param ControllerHandle - Handle of device to stop driver on.
97 @param NumberOfChildren - Not used.
98 @param ChildHandleBuffer - Not used.
99
100 @retval EFI_SUCCESS - This driver is removed DeviceHandle.
101 @return other - This driver was not removed from this device.
102
103**/
104EFI_STATUS
105EFIAPI
106FatDriverBindingStop (
107 IN EFI_DRIVER_BINDING_PROTOCOL *This,
108 IN EFI_HANDLE Controller,
109 IN UINTN NumberOfChildren,
110 IN EFI_HANDLE *ChildHandleBuffer
111 );
112
113//
114// DriverBinding protocol instance
115//
116EFI_DRIVER_BINDING_PROTOCOL gFatDriverBinding = {
117 FatDriverBindingSupported,
118 FatDriverBindingStart,
119 FatDriverBindingStop,
120 0xa,
121 NULL,
122 NULL
123};
124
125/**
126
127 Register Driver Binding protocol for this driver.
128
129 @param ImageHandle - Handle for the image of this driver.
130 @param SystemTable - Pointer to the EFI System Table.
131
132 @retval EFI_SUCCESS - Driver loaded.
133 @return other - Driver not loaded.
134
135**/
136EFI_STATUS
137EFIAPI
138FatEntryPoint (
139 IN EFI_HANDLE ImageHandle,
140 IN EFI_SYSTEM_TABLE *SystemTable
141 )
142{
143 EFI_STATUS Status;
144
145 //
146 // Initialize the EFI Driver Library
147 //
148 Status = EfiLibInstallDriverBindingComponentName2 (
149 ImageHandle,
150 SystemTable,
151 &gFatDriverBinding,
152 ImageHandle,
153 &gFatComponentName,
154 &gFatComponentName2
155 );
156 ASSERT_EFI_ERROR (Status);
157
158 return Status;
159}
160
161/**
162
163 Unload function for this image. Uninstall DriverBinding protocol.
164
165 @param ImageHandle - Handle for the image of this driver.
166
167 @retval EFI_SUCCESS - Driver unloaded successfully.
168 @return other - Driver can not unloaded.
169
170**/
171EFI_STATUS
172EFIAPI
173FatUnload (
174 IN EFI_HANDLE ImageHandle
175 )
176{
177 EFI_STATUS Status;
178 EFI_HANDLE *DeviceHandleBuffer;
179 UINTN DeviceHandleCount;
180 UINTN Index;
181 VOID *ComponentName;
182 VOID *ComponentName2;
183
184 Status = gBS->LocateHandleBuffer (
185 AllHandles,
186 NULL,
187 NULL,
188 &DeviceHandleCount,
189 &DeviceHandleBuffer
190 );
191 if (EFI_ERROR (Status)) {
192 return Status;
193 }
194
195 for (Index = 0; Index < DeviceHandleCount; Index++) {
196 Status = EfiTestManagedDevice (DeviceHandleBuffer[Index], ImageHandle, &gEfiDiskIoProtocolGuid);
197 if (!EFI_ERROR (Status)) {
198 Status = gBS->DisconnectController (
199 DeviceHandleBuffer[Index],
200 ImageHandle,
201 NULL
202 );
203 if (EFI_ERROR (Status)) {
204 break;
205 }
206 }
207 }
208
209 if (Index == DeviceHandleCount) {
210 //
211 // Driver is stopped successfully.
212 //
213 Status = gBS->HandleProtocol (ImageHandle, &gEfiComponentNameProtocolGuid, &ComponentName);
214 if (EFI_ERROR (Status)) {
215 ComponentName = NULL;
216 }
217
218 Status = gBS->HandleProtocol (ImageHandle, &gEfiComponentName2ProtocolGuid, &ComponentName2);
219 if (EFI_ERROR (Status)) {
220 ComponentName2 = NULL;
221 }
222
223 if (ComponentName == NULL) {
224 if (ComponentName2 == NULL) {
225 Status = gBS->UninstallMultipleProtocolInterfaces (
226 ImageHandle,
227 &gEfiDriverBindingProtocolGuid,
228 &gFatDriverBinding,
229 NULL
230 );
231 } else {
232 Status = gBS->UninstallMultipleProtocolInterfaces (
233 ImageHandle,
234 &gEfiDriverBindingProtocolGuid,
235 &gFatDriverBinding,
236 &gEfiComponentName2ProtocolGuid,
237 ComponentName2,
238 NULL
239 );
240 }
241 } else {
242 if (ComponentName2 == NULL) {
243 Status = gBS->UninstallMultipleProtocolInterfaces (
244 ImageHandle,
245 &gEfiDriverBindingProtocolGuid,
246 &gFatDriverBinding,
247 &gEfiComponentNameProtocolGuid,
248 ComponentName,
249 NULL
250 );
251 } else {
252 Status = gBS->UninstallMultipleProtocolInterfaces (
253 ImageHandle,
254 &gEfiDriverBindingProtocolGuid,
255 &gFatDriverBinding,
256 &gEfiComponentNameProtocolGuid,
257 ComponentName,
258 &gEfiComponentName2ProtocolGuid,
259 ComponentName2,
260 NULL
261 );
262 }
263 }
264 }
265
266 if (DeviceHandleBuffer != NULL) {
267 FreePool (DeviceHandleBuffer);
268 }
269
270 return Status;
271}
272
273/**
274
275 Test to see if this driver can add a file system to ControllerHandle.
276 ControllerHandle must support both Disk IO and Block IO protocols.
277
278 @param This - Protocol instance pointer.
279 @param ControllerHandle - Handle of device to test.
280 @param RemainingDevicePath - Not used.
281
282 @retval EFI_SUCCESS - This driver supports this device.
283 @retval EFI_ALREADY_STARTED - This driver is already running on this device.
284 @return other - This driver does not support this device.
285
286**/
287EFI_STATUS
288EFIAPI
289FatDriverBindingSupported (
290 IN EFI_DRIVER_BINDING_PROTOCOL *This,
291 IN EFI_HANDLE ControllerHandle,
292 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
293 )
294{
295 EFI_STATUS Status;
296 EFI_DISK_IO_PROTOCOL *DiskIo;
297
298 //
299 // Open the IO Abstraction(s) needed to perform the supported test
300 //
301 Status = gBS->OpenProtocol (
302 ControllerHandle,
303 &gEfiDiskIoProtocolGuid,
304 (VOID **)&DiskIo,
305 This->DriverBindingHandle,
306 ControllerHandle,
307 EFI_OPEN_PROTOCOL_BY_DRIVER
308 );
309
310 if (EFI_ERROR (Status)) {
311 return Status;
312 }
313
314 //
315 // Close the I/O Abstraction(s) used to perform the supported test
316 //
317 gBS->CloseProtocol (
318 ControllerHandle,
319 &gEfiDiskIoProtocolGuid,
320 This->DriverBindingHandle,
321 ControllerHandle
322 );
323
324 //
325 // Open the IO Abstraction(s) needed to perform the supported test
326 //
327 Status = gBS->OpenProtocol (
328 ControllerHandle,
329 &gEfiBlockIoProtocolGuid,
330 NULL,
331 This->DriverBindingHandle,
332 ControllerHandle,
333 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
334 );
335
336 return Status;
337}
338
339/**
340
341 Start this driver on ControllerHandle by opening a Block IO and Disk IO
342 protocol, reading Device Path. Add a Simple File System protocol to
343 ControllerHandle if the media contains a valid file system.
344
345 @param This - Protocol instance pointer.
346 @param ControllerHandle - Handle of device to bind driver to.
347 @param RemainingDevicePath - Not used.
348
349 @retval EFI_SUCCESS - This driver is added to DeviceHandle.
350 @retval EFI_ALREADY_STARTED - This driver is already running on DeviceHandle.
351 @retval EFI_OUT_OF_RESOURCES - Can not allocate the memory.
352 @return other - This driver does not support this device.
353
354**/
355EFI_STATUS
356EFIAPI
357FatDriverBindingStart (
358 IN EFI_DRIVER_BINDING_PROTOCOL *This,
359 IN EFI_HANDLE ControllerHandle,
360 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
361 )
362{
363 EFI_STATUS Status;
364 EFI_BLOCK_IO_PROTOCOL *BlockIo;
365 EFI_DISK_IO_PROTOCOL *DiskIo;
366 EFI_DISK_IO2_PROTOCOL *DiskIo2;
367 BOOLEAN LockedByMe;
368
369 LockedByMe = FALSE;
370 //
371 // Acquire the lock.
372 // If caller has already acquired the lock, cannot lock it again.
373 //
374 Status = FatAcquireLockOrFail ();
375 if (!EFI_ERROR (Status)) {
376 LockedByMe = TRUE;
377 }
378
379 Status = InitializeUnicodeCollationSupport (This->DriverBindingHandle);
380 if (EFI_ERROR (Status)) {
381 goto Exit;
382 }
383
384 //
385 // Open our required BlockIo and DiskIo
386 //
387 Status = gBS->OpenProtocol (
388 ControllerHandle,
389 &gEfiBlockIoProtocolGuid,
390 (VOID **)&BlockIo,
391 This->DriverBindingHandle,
392 ControllerHandle,
393 EFI_OPEN_PROTOCOL_GET_PROTOCOL
394 );
395 if (EFI_ERROR (Status)) {
396 goto Exit;
397 }
398
399 Status = gBS->OpenProtocol (
400 ControllerHandle,
401 &gEfiDiskIoProtocolGuid,
402 (VOID **)&DiskIo,
403 This->DriverBindingHandle,
404 ControllerHandle,
405 EFI_OPEN_PROTOCOL_BY_DRIVER
406 );
407 if (EFI_ERROR (Status)) {
408 goto Exit;
409 }
410
411 Status = gBS->OpenProtocol (
412 ControllerHandle,
413 &gEfiDiskIo2ProtocolGuid,
414 (VOID **)&DiskIo2,
415 This->DriverBindingHandle,
416 ControllerHandle,
417 EFI_OPEN_PROTOCOL_BY_DRIVER
418 );
419 if (EFI_ERROR (Status)) {
420 DiskIo2 = NULL;
421 }
422
423 //
424 // Allocate Volume structure. In FatAllocateVolume(), Resources
425 // are allocated with protocol installed and cached initialized
426 //
427 Status = FatAllocateVolume (ControllerHandle, DiskIo, DiskIo2, BlockIo);
428
429 //
430 // When the media changes on a device it will Reinstall the BlockIo interface.
431 // This will cause a call to our Stop(), and a subsequent reentrant call to our
432 // Start() successfully. We should leave the device open when this happen.
433 //
434 if (EFI_ERROR (Status)) {
435 Status = gBS->OpenProtocol (
436 ControllerHandle,
437 &gEfiSimpleFileSystemProtocolGuid,
438 NULL,
439 This->DriverBindingHandle,
440 ControllerHandle,
441 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
442 );
443 if (EFI_ERROR (Status)) {
444 gBS->CloseProtocol (
445 ControllerHandle,
446 &gEfiDiskIoProtocolGuid,
447 This->DriverBindingHandle,
448 ControllerHandle
449 );
450 gBS->CloseProtocol (
451 ControllerHandle,
452 &gEfiDiskIo2ProtocolGuid,
453 This->DriverBindingHandle,
454 ControllerHandle
455 );
456 }
457 }
458
459Exit:
460 //
461 // Unlock if locked by myself.
462 //
463 if (LockedByMe) {
464 FatReleaseLock ();
465 }
466
467 return Status;
468}
469
470/**
471
472 Stop this driver on ControllerHandle.
473
474 @param This - Protocol instance pointer.
475 @param ControllerHandle - Handle of device to stop driver on.
476 @param NumberOfChildren - Not used.
477 @param ChildHandleBuffer - Not used.
478
479 @retval EFI_SUCCESS - This driver is removed DeviceHandle.
480 @return other - This driver was not removed from this device.
481
482**/
483EFI_STATUS
484EFIAPI
485FatDriverBindingStop (
486 IN EFI_DRIVER_BINDING_PROTOCOL *This,
487 IN EFI_HANDLE ControllerHandle,
488 IN UINTN NumberOfChildren,
489 IN EFI_HANDLE *ChildHandleBuffer
490 )
491{
492 EFI_STATUS Status;
493 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *FileSystem;
494 FAT_VOLUME *Volume;
495 EFI_DISK_IO2_PROTOCOL *DiskIo2;
496
497 DiskIo2 = NULL;
498 //
499 // Get our context back
500 //
501 Status = gBS->OpenProtocol (
502 ControllerHandle,
503 &gEfiSimpleFileSystemProtocolGuid,
504 (VOID **)&FileSystem,
505 This->DriverBindingHandle,
506 ControllerHandle,
507 EFI_OPEN_PROTOCOL_GET_PROTOCOL
508 );
509
510 if (!EFI_ERROR (Status)) {
511 Volume = VOLUME_FROM_VOL_INTERFACE (FileSystem);
512 DiskIo2 = Volume->DiskIo2;
513 Status = FatAbandonVolume (Volume);
514 }
515
516 if (!EFI_ERROR (Status)) {
517 if (DiskIo2 != NULL) {
518 Status = gBS->CloseProtocol (
519 ControllerHandle,
520 &gEfiDiskIo2ProtocolGuid,
521 This->DriverBindingHandle,
522 ControllerHandle
523 );
524 ASSERT_EFI_ERROR (Status);
525 }
526
527 Status = gBS->CloseProtocol (
528 ControllerHandle,
529 &gEfiDiskIoProtocolGuid,
530 This->DriverBindingHandle,
531 ControllerHandle
532 );
533 ASSERT_EFI_ERROR (Status);
534 }
535
536 return Status;
537}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette