3 Copyright (c) 2006, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 Produce block IO abstractions for real devices on your PC using Win32 APIs.
19 The configuration of what devices to mount or emulate comes from NT
20 environment variables. The variables must be visible to the Microsoft*
21 Developer Studio for them to work.
23 <F>ixed - Fixed disk like a hard drive.
24 <R>emovable - Removable media like a floppy or CD-ROM.
25 Read <O>nly - Write protected device.
26 Read <W>rite - Read write device.
27 <block count> - Decimal number of blocks a device supports.
28 <block size> - Decimal number of bytes per block.
30 NT envirnonment variable contents. '<' and '>' are not part of the variable,
31 they are just used to make this help more readable. There should be no
32 spaces between the ';'. Extra spaces will break the variable. A '!' is
33 used to seperate multiple devices in a variable.
35 EFI_WIN_NT_VIRTUAL_DISKS =
36 <F | R><O | W>;<block count>;<block size>[!...]
38 EFI_WIN_NT_PHYSICAL_DISKS =
39 <drive letter>:<F | R><O | W>;<block count>;<block size>[!...]
41 Virtual Disks: These devices use a file to emulate a hard disk or removable
44 Thus a 20 MB emulated hard drive would look like:
45 EFI_WIN_NT_VIRTUAL_DISKS=FW;40960;512
47 A 1.44MB emulated floppy with a block size of 1024 would look like:
48 EFI_WIN_NT_VIRTUAL_DISKS=RW;1440;1024
50 Physical Disks: These devices use NT to open a real device in your system
52 Thus a 120 MB floppy would look like:
53 EFI_WIN_NT_PHYSICAL_DISKS=B:RW;245760;512
55 Thus a standard CD-ROM floppy would look like:
56 EFI_WIN_NT_PHYSICAL_DISKS=Z:RO;307200;2048
59 * Other names and brands may be claimed as the property of others.
63 #include "WinNtBlockIo.h"
65 EFI_DRIVER_BINDING_PROTOCOL gWinNtBlockIoDriverBinding
= {
66 WinNtBlockIoDriverBindingSupported
,
67 WinNtBlockIoDriverBindingStart
,
68 WinNtBlockIoDriverBindingStop
,
77 WinNtBlockIoDriverBindingSupported (
78 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
80 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
93 // TODO: This - add argument and description to function comment
94 // TODO: Handle - add argument and description to function comment
95 // TODO: RemainingDevicePath - add argument and description to function comment
98 EFI_WIN_NT_IO_PROTOCOL
*WinNtIo
;
101 // Open the IO Abstraction(s) needed to perform the supported test
103 Status
= gBS
->OpenProtocol (
105 &gEfiWinNtIoProtocolGuid
,
107 This
->DriverBindingHandle
,
109 EFI_OPEN_PROTOCOL_BY_DRIVER
111 if (EFI_ERROR (Status
)) {
116 // Make sure the WinNtThunkProtocol is valid
118 Status
= EFI_UNSUPPORTED
;
119 if (WinNtIo
->WinNtThunk
->Signature
== EFI_WIN_NT_THUNK_PROTOCOL_SIGNATURE
) {
122 // Check the GUID to see if this is a handle type the driver supports
124 if (CompareGuid (WinNtIo
->TypeGuid
, &gEfiWinNtVirtualDisksGuid
) ||
125 CompareGuid (WinNtIo
->TypeGuid
, &gEfiWinNtPhysicalDisksGuid
) ) {
126 Status
= EFI_SUCCESS
;
131 // Close the I/O Abstraction(s) used to perform the supported test
135 &gEfiWinNtIoProtocolGuid
,
136 This
->DriverBindingHandle
,
145 WinNtBlockIoDriverBindingStart (
146 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
147 IN EFI_HANDLE Handle
,
148 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
161 // TODO: This - add argument and description to function comment
162 // TODO: Handle - add argument and description to function comment
163 // TODO: RemainingDevicePath - add argument and description to function comment
166 EFI_WIN_NT_IO_PROTOCOL
*WinNtIo
;
167 WIN_NT_RAW_DISK_DEVICE_TYPE DiskType
;
168 UINT16 Buffer
[FILENAME_BUFFER_SIZE
];
170 BOOLEAN RemovableMedia
;
171 BOOLEAN WriteProtected
;
172 UINTN NumberOfBlocks
;
176 // Grab the protocols we need
178 Status
= gBS
->OpenProtocol (
180 &gEfiWinNtIoProtocolGuid
,
182 This
->DriverBindingHandle
,
184 EFI_OPEN_PROTOCOL_BY_DRIVER
186 if (EFI_ERROR (Status
)) {
193 if (CompareGuid (WinNtIo
->TypeGuid
, &gEfiWinNtVirtualDisksGuid
)) {
194 DiskType
= EfiWinNtVirtualDisks
;
195 } else if (CompareGuid (WinNtIo
->TypeGuid
, &gEfiWinNtPhysicalDisksGuid
)) {
196 DiskType
= EfiWinNtPhysicalDisks
;
198 Status
= EFI_UNSUPPORTED
;
202 Status
= EFI_NOT_FOUND
;
203 Str
= WinNtIo
->EnvString
;
204 if (DiskType
== EfiWinNtVirtualDisks
) {
205 WinNtIo
->WinNtThunk
->SPrintf (
208 WinNtIo
->InstanceNumber
211 if (*Str
>= 'A' && *Str
<= 'Z' || *Str
>= 'a' && *Str
<= 'z') {
212 WinNtIo
->WinNtThunk
->SPrintf (Buffer
, L
"\\\\.\\%c:", *Str
);
214 WinNtIo
->WinNtThunk
->SPrintf (Buffer
, L
"\\\\.\\PHYSICALDRIVE%c", *Str
);
219 Status
= EFI_NOT_FOUND
;
226 if (*Str
== 'R' || *Str
== 'F') {
227 RemovableMedia
= (BOOLEAN
) (*Str
== 'R');
229 if (*Str
== 'O' || *Str
== 'W') {
230 WriteProtected
= (BOOLEAN
) (*Str
== 'O');
231 Str
= GetNextElementPastTerminator (Str
, ';');
233 NumberOfBlocks
= Atoi (Str
);
234 if (NumberOfBlocks
!= 0) {
235 Str
= GetNextElementPastTerminator (Str
, ';');
236 BlockSize
= Atoi (Str
);
237 if (BlockSize
!= 0) {
239 // If we get here the variable is valid so do the work.
241 Status
= WinNtBlockIoCreateMapping (
258 if (EFI_ERROR (Status
)) {
261 &gEfiWinNtIoProtocolGuid
,
262 This
->DriverBindingHandle
,
272 WinNtBlockIoDriverBindingStop (
273 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
274 IN EFI_HANDLE Handle
,
275 IN UINTN NumberOfChildren
,
276 IN EFI_HANDLE
*ChildHandleBuffer
282 TODO: Add function description
286 This - TODO: add argument description
287 Handle - TODO: add argument description
288 NumberOfChildren - TODO: add argument description
289 ChildHandleBuffer - TODO: add argument description
293 EFI_UNSUPPORTED - TODO: Add description for return value
297 EFI_BLOCK_IO_PROTOCOL
*BlockIo
;
299 WIN_NT_BLOCK_IO_PRIVATE
*Private
;
302 // Get our context back
304 Status
= gBS
->OpenProtocol (
306 &gEfiBlockIoProtocolGuid
,
308 This
->DriverBindingHandle
,
310 EFI_OPEN_PROTOCOL_GET_PROTOCOL
312 if (EFI_ERROR (Status
)) {
313 return EFI_UNSUPPORTED
;
316 Private
= WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (BlockIo
);
319 // BugBug: If we need to kick people off, we need to make Uninstall Close the handles.
320 // We could pass in our image handle or FLAG our open to be closed via
321 // Unistall (== to saying any CloseProtocol will close our open)
323 Status
= gBS
->UninstallMultipleProtocolInterfaces (
325 &gEfiBlockIoProtocolGuid
,
329 if (!EFI_ERROR (Status
)) {
331 Status
= gBS
->CloseProtocol (
333 &gEfiWinNtIoProtocolGuid
,
334 This
->DriverBindingHandle
,
339 // Shut down our device
341 Private
->WinNtThunk
->CloseHandle (Private
->NtHandle
);
344 // Free our instance data
346 FreeUnicodeStringTable (Private
->ControllerNameTable
);
348 gBS
->FreePool (Private
);
356 GetNextElementPastTerminator (
357 IN CHAR16
*EnvironmentVariable
,
364 Worker function to parse environment variables.
367 EnvironmentVariable - Envirnment variable to parse.
369 Terminator - Terminator to parse for.
373 Pointer to next eliment past the first occurence of Terminator or the '\0'
374 at the end of the string.
380 for (Ptr
= EnvironmentVariable
; *Ptr
!= '\0'; Ptr
++) {
381 if (*Ptr
== Terminator
) {
392 WinNtBlockIoCreateMapping (
393 IN EFI_WIN_NT_IO_PROTOCOL
*WinNtIo
,
394 IN EFI_HANDLE EfiDeviceHandle
,
397 IN BOOLEAN RemovableMedia
,
398 IN UINTN NumberOfBlocks
,
400 IN WIN_NT_RAW_DISK_DEVICE_TYPE DeviceType
406 TODO: Add function description
410 WinNtIo - TODO: add argument description
411 EfiDeviceHandle - TODO: add argument description
412 Filename - TODO: add argument description
413 ReadOnly - TODO: add argument description
414 RemovableMedia - TODO: add argument description
415 NumberOfBlocks - TODO: add argument description
416 BlockSize - TODO: add argument description
417 DeviceType - TODO: add argument description
421 TODO: add return values
426 EFI_BLOCK_IO_PROTOCOL
*BlockIo
;
427 WIN_NT_BLOCK_IO_PRIVATE
*Private
;
430 WinNtIo
->WinNtThunk
->SetErrorMode (SEM_FAILCRITICALERRORS
);
432 Status
= gBS
->AllocatePool (
434 sizeof (WIN_NT_BLOCK_IO_PRIVATE
),
437 ASSERT_EFI_ERROR (Status
);
439 EfiInitializeLock (&Private
->Lock
, EFI_TPL_NOTIFY
);
441 Private
->WinNtThunk
= WinNtIo
->WinNtThunk
;
443 Private
->Signature
= WIN_NT_BLOCK_IO_PRIVATE_SIGNATURE
;
444 Private
->LastBlock
= NumberOfBlocks
- 1;
445 Private
->BlockSize
= BlockSize
;
447 for (Index
= 0; Filename
[Index
] != 0; Index
++) {
448 Private
->Filename
[Index
] = Filename
[Index
];
451 Private
->Filename
[Index
] = 0;
453 Private
->ReadMode
= GENERIC_READ
| (ReadOnly
? 0 : GENERIC_WRITE
);
454 Private
->ShareMode
= FILE_SHARE_READ
| FILE_SHARE_WRITE
;
456 Private
->NumberOfBlocks
= NumberOfBlocks
;
457 Private
->DeviceType
= DeviceType
;
458 Private
->NtHandle
= INVALID_HANDLE_VALUE
;
460 Private
->ControllerNameTable
= NULL
;
464 gWinNtBlockIoComponentName
.SupportedLanguages
,
465 &Private
->ControllerNameTable
,
469 BlockIo
= &Private
->BlockIo
;
470 BlockIo
->Revision
= EFI_BLOCK_IO_PROTOCOL_REVISION
;
471 BlockIo
->Media
= &Private
->Media
;
472 BlockIo
->Media
->BlockSize
= Private
->BlockSize
;
473 BlockIo
->Media
->LastBlock
= Private
->NumberOfBlocks
- 1;
474 BlockIo
->Media
->MediaId
= 0;;
476 BlockIo
->Reset
= WinNtBlockIoResetBlock
;
477 BlockIo
->ReadBlocks
= WinNtBlockIoReadBlocks
;
478 BlockIo
->WriteBlocks
= WinNtBlockIoWriteBlocks
;
479 BlockIo
->FlushBlocks
= WinNtBlockIoFlushBlocks
;
481 BlockIo
->Media
->ReadOnly
= ReadOnly
;
482 BlockIo
->Media
->RemovableMedia
= RemovableMedia
;
483 BlockIo
->Media
->LogicalPartition
= FALSE
;
484 BlockIo
->Media
->MediaPresent
= TRUE
;
485 BlockIo
->Media
->WriteCaching
= FALSE
;
487 if (DeviceType
== EfiWinNtVirtualDisks
) {
488 BlockIo
->Media
->IoAlign
= 1;
491 // Create a file to use for a virtual disk even if it does not exist.
493 Private
->OpenMode
= OPEN_ALWAYS
;
494 } else if (DeviceType
== EfiWinNtPhysicalDisks
) {
496 // Physical disk and floppy devices require 4 byte alignment.
498 BlockIo
->Media
->IoAlign
= 4;
501 // You can only open a physical device if it exists.
503 Private
->OpenMode
= OPEN_EXISTING
;
508 Private
->EfiHandle
= EfiDeviceHandle
;
509 Status
= WinNtBlockIoOpenDevice (Private
);
510 if (!EFI_ERROR (Status
)) {
512 Status
= gBS
->InstallMultipleProtocolInterfaces (
514 &gEfiBlockIoProtocolGuid
,
518 if (EFI_ERROR (Status
)) {
519 FreeUnicodeStringTable (Private
->ControllerNameTable
);
520 gBS
->FreePool (Private
);
523 DEBUG ((EFI_D_INIT
, "BlockDevice added: %s\n", Filename
));
531 WinNtBlockIoOpenDevice (
532 WIN_NT_BLOCK_IO_PRIVATE
*Private
538 TODO: Add function description
542 Private - TODO: add argument description
546 TODO: add return values
553 EFI_BLOCK_IO_PROTOCOL
*BlockIo
;
555 BlockIo
= &Private
->BlockIo
;
556 EfiAcquireLock (&Private
->Lock
);
559 // If the device is already opened, close it
561 if (Private
->NtHandle
!= INVALID_HANDLE_VALUE
) {
562 BlockIo
->Reset (BlockIo
, FALSE
);
568 Private
->NtHandle
= Private
->WinNtThunk
->CreateFile (
578 Status
= Private
->WinNtThunk
->GetLastError ();
580 if (Private
->NtHandle
== INVALID_HANDLE_VALUE
) {
581 DEBUG ((EFI_D_INFO
, "PlOpenBlock: Could not open %s, %x\n", Private
->Filename
, Private
->WinNtThunk
->GetLastError ()));
582 BlockIo
->Media
->MediaPresent
= FALSE
;
583 Status
= EFI_NO_MEDIA
;
587 if (!BlockIo
->Media
->MediaPresent
) {
589 // BugBug: try to emulate if a CD appears - notify drivers to check it out
591 BlockIo
->Media
->MediaPresent
= TRUE
;
592 EfiReleaseLock (&Private
->Lock
);
593 EfiAcquireLock (&Private
->Lock
);
597 // get the size of the file
599 Status
= SetFilePointer64 (Private
, 0, &FileSize
, FILE_END
);
601 if (EFI_ERROR (Status
)) {
602 FileSize
= MultU64x32 (Private
->NumberOfBlocks
, Private
->BlockSize
);
603 if (Private
->DeviceType
== EfiWinNtVirtualDisks
) {
604 DEBUG ((EFI_D_ERROR
, "PlOpenBlock: Could not get filesize of %s\n", Private
->Filename
));
605 Status
= EFI_UNSUPPORTED
;
610 if (Private
->NumberOfBlocks
== 0) {
611 Private
->NumberOfBlocks
= DivU64x32 (FileSize
, Private
->BlockSize
);
614 EndOfFile
= MultU64x32 (Private
->NumberOfBlocks
, Private
->BlockSize
);
616 if (FileSize
!= EndOfFile
) {
618 // file is not the proper size, change it
620 DEBUG ((EFI_D_INIT
, "PlOpenBlock: Initializing block device: %hs\n", Private
->Filename
));
625 SetFilePointer64 (Private
, 0, NULL
, FILE_BEGIN
);
626 Private
->WinNtThunk
->SetEndOfFile (Private
->NtHandle
);
629 // then set it to the needed file size (OS will zero fill it)
631 SetFilePointer64 (Private
, EndOfFile
, NULL
, FILE_BEGIN
);
632 Private
->WinNtThunk
->SetEndOfFile (Private
->NtHandle
);
635 DEBUG ((EFI_D_INIT
, "%HPlOpenBlock: opened %s%N\n", Private
->Filename
));
636 Status
= EFI_SUCCESS
;
639 if (EFI_ERROR (Status
)) {
640 if (Private
->NtHandle
!= INVALID_HANDLE_VALUE
) {
641 BlockIo
->Reset (BlockIo
, FALSE
);
645 EfiReleaseLock (&Private
->Lock
);
652 IN WIN_NT_BLOCK_IO_PRIVATE
*Private
658 TODO: Add function description
662 Private - TODO: add argument description
666 TODO: add return values
670 EFI_BLOCK_IO_PROTOCOL
*BlockIo
;
672 BOOLEAN ReinstallBlockIoFlag
;
674 BlockIo
= &Private
->BlockIo
;
676 switch (Private
->WinNtThunk
->GetLastError ()) {
678 case ERROR_NOT_READY
:
679 Status
= EFI_NO_MEDIA
;
680 BlockIo
->Media
->ReadOnly
= FALSE
;
681 BlockIo
->Media
->MediaPresent
= FALSE
;
682 ReinstallBlockIoFlag
= FALSE
;
685 case ERROR_WRONG_DISK
:
686 BlockIo
->Media
->ReadOnly
= FALSE
;
687 BlockIo
->Media
->MediaPresent
= TRUE
;
688 BlockIo
->Media
->MediaId
+= 1;
689 ReinstallBlockIoFlag
= TRUE
;
690 Status
= EFI_MEDIA_CHANGED
;
693 case ERROR_WRITE_PROTECT
:
694 BlockIo
->Media
->ReadOnly
= TRUE
;
695 ReinstallBlockIoFlag
= FALSE
;
696 Status
= EFI_WRITE_PROTECTED
;
700 ReinstallBlockIoFlag
= FALSE
;
701 Status
= EFI_DEVICE_ERROR
;
705 if (ReinstallBlockIoFlag
) {
706 BlockIo
->Reset (BlockIo
, FALSE
);
708 gBS
->ReinstallProtocolInterface (
710 &gEfiBlockIoProtocolGuid
,
721 WinNtBlockIoReadWriteCommon (
722 IN WIN_NT_BLOCK_IO_PRIVATE
*Private
,
733 TODO: Add function description
737 Private - TODO: add argument description
738 MediaId - TODO: add argument description
739 Lba - TODO: add argument description
740 BufferSize - TODO: add argument description
741 Buffer - TODO: add argument description
742 CallerName - TODO: add argument description
746 EFI_NO_MEDIA - TODO: Add description for return value
747 EFI_MEDIA_CHANGED - TODO: Add description for return value
748 EFI_INVALID_PARAMETER - TODO: Add description for return value
749 EFI_SUCCESS - TODO: Add description for return value
750 EFI_BAD_BUFFER_SIZE - TODO: Add description for return value
751 EFI_INVALID_PARAMETER - TODO: Add description for return value
752 EFI_SUCCESS - TODO: Add description for return value
759 INT64 DistanceToMove
;
760 UINT64 DistanceMoved
;
762 if (Private
->NtHandle
== INVALID_HANDLE_VALUE
) {
763 Status
= WinNtBlockIoOpenDevice (Private
);
764 if (EFI_ERROR (Status
)) {
769 if (!Private
->Media
.MediaPresent
) {
770 DEBUG ((EFI_D_INIT
, "%s: No Media\n", CallerName
));
774 if (Private
->Media
.MediaId
!= MediaId
) {
775 return EFI_MEDIA_CHANGED
;
778 if ((UINT32
) Buffer
% Private
->Media
.IoAlign
!= 0) {
779 return EFI_INVALID_PARAMETER
;
783 // Verify buffer size
785 BlockSize
= Private
->BlockSize
;
786 if (BufferSize
== 0) {
787 DEBUG ((EFI_D_INIT
, "%s: Zero length read\n", CallerName
));
791 if ((BufferSize
% BlockSize
) != 0) {
792 DEBUG ((EFI_D_INIT
, "%s: Invalid read size\n", CallerName
));
793 return EFI_BAD_BUFFER_SIZE
;
796 LastBlock
= Lba
+ (BufferSize
/ BlockSize
) - 1;
797 if (LastBlock
> Private
->LastBlock
) {
798 DEBUG ((EFI_D_INIT
, "ReadBlocks: Attempted to read off end of device\n"));
799 return EFI_INVALID_PARAMETER
;
802 // Seek to End of File
804 DistanceToMove
= MultU64x32 (Lba
, BlockSize
);
805 Status
= SetFilePointer64 (Private
, DistanceToMove
, &DistanceMoved
, FILE_BEGIN
);
807 if (EFI_ERROR (Status
)) {
808 DEBUG ((EFI_D_INIT
, "WriteBlocks: SetFilePointer failed\n"));
809 return WinNtBlockIoError (Private
);
818 WinNtBlockIoReadBlocks (
819 IN EFI_BLOCK_IO_PROTOCOL
*This
,
828 Read BufferSize bytes from Lba into Buffer.
831 This - Protocol instance pointer.
832 MediaId - Id of the media, changes every time the media is replaced.
833 Lba - The starting Logical Block Address to read from
834 BufferSize - Size of Buffer, must be a multiple of device block size.
835 Buffer - Buffer containing read data
838 EFI_SUCCESS - The data was read correctly from the device.
839 EFI_DEVICE_ERROR - The device reported an error while performing the read.
840 EFI_NO_MEDIA - There is no media in the device.
841 EFI_MEDIA_CHANGED - The MediaId does not matched the current device.
842 EFI_BAD_BUFFER_SIZE - The Buffer was not a multiple of the block size of the
844 EFI_INVALID_PARAMETER - The read request contains device addresses that are not
845 valid for the device.
849 WIN_NT_BLOCK_IO_PRIVATE
*Private
;
854 Private
= WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This
);
856 Status
= WinNtBlockIoReadWriteCommon (Private
, MediaId
, Lba
, BufferSize
, Buffer
, "WinNtReadBlocks");
857 if (EFI_ERROR (Status
)) {
861 Flag
= Private
->WinNtThunk
->ReadFile (Private
->NtHandle
, Buffer
, (DWORD
) BufferSize
, (LPDWORD
) &BytesRead
, NULL
);
862 if (!Flag
|| (BytesRead
!= BufferSize
)) {
863 DEBUG ((EFI_D_INIT
, "ReadBlocks: ReadFile failed. (%d)\n", Private
->WinNtThunk
->GetLastError ()));
864 return WinNtBlockIoError (Private
);
868 // If we wrote then media is present.
870 This
->Media
->MediaPresent
= TRUE
;
877 WinNtBlockIoWriteBlocks (
878 IN EFI_BLOCK_IO_PROTOCOL
*This
,
887 Write BufferSize bytes from Lba into Buffer.
890 This - Protocol instance pointer.
891 MediaId - Id of the media, changes every time the media is replaced.
892 Lba - The starting Logical Block Address to read from
893 BufferSize - Size of Buffer, must be a multiple of device block size.
894 Buffer - Buffer containing read data
897 EFI_SUCCESS - The data was written correctly to the device.
898 EFI_WRITE_PROTECTED - The device can not be written to.
899 EFI_DEVICE_ERROR - The device reported an error while performing the write.
900 EFI_NO_MEDIA - There is no media in the device.
901 EFI_MEDIA_CHNAGED - The MediaId does not matched the current device.
902 EFI_BAD_BUFFER_SIZE - The Buffer was not a multiple of the block size of the
904 EFI_INVALID_PARAMETER - The write request contains a LBA that is not
905 valid for the device.
909 WIN_NT_BLOCK_IO_PRIVATE
*Private
;
914 Private
= WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This
);
916 Status
= WinNtBlockIoReadWriteCommon (Private
, MediaId
, Lba
, BufferSize
, Buffer
, "WinNtWriteBlocks");
917 if (EFI_ERROR (Status
)) {
921 Flag
= Private
->WinNtThunk
->WriteFile (Private
->NtHandle
, Buffer
, (DWORD
) BufferSize
, (LPDWORD
) &BytesWritten
, NULL
);
922 if (!Flag
|| (BytesWritten
!= BufferSize
)) {
923 DEBUG ((EFI_D_INIT
, "ReadBlocks: WriteFile failed. (%d)\n", Private
->WinNtThunk
->GetLastError ()));
924 return WinNtBlockIoError (Private
);
928 // If the write succeeded, we are not write protected and media is present.
930 This
->Media
->MediaPresent
= TRUE
;
931 This
->Media
->ReadOnly
= FALSE
;
938 WinNtBlockIoFlushBlocks (
939 IN EFI_BLOCK_IO_PROTOCOL
*This
944 Flush the Block Device.
947 This - Protocol instance pointer.
950 EFI_SUCCESS - All outstanding data was written to the device
951 EFI_DEVICE_ERROR - The device reported an error while writting back the data
952 EFI_NO_MEDIA - There is no media in the device.
962 WinNtBlockIoResetBlock (
963 IN EFI_BLOCK_IO_PROTOCOL
*This
,
964 IN BOOLEAN ExtendedVerification
969 Reset the Block Device.
972 This - Protocol instance pointer.
973 ExtendedVerification - Driver may perform diagnostics on reset.
976 EFI_SUCCESS - The device was reset.
977 EFI_DEVICE_ERROR - The device is not functioning properly and could
982 WIN_NT_BLOCK_IO_PRIVATE
*Private
;
984 Private
= WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This
);
986 if (Private
->NtHandle
!= INVALID_HANDLE_VALUE
) {
987 Private
->WinNtThunk
->CloseHandle (Private
->NtHandle
);
988 Private
->NtHandle
= INVALID_HANDLE_VALUE
;
1000 Routine Description:
1002 Convert a unicode string to a UINTN
1006 String - Unicode string.
1010 UINTN of the number represented by String.
1018 // skip preceeding white space
1021 while ((*Str
) && (*Str
== ' ')) {
1025 // Convert ot a Number
1028 while (*Str
!= '\0') {
1029 if ((*Str
>= '0') && (*Str
<= '9')) {
1030 Number
= (Number
* 10) +*Str
- '0';
1043 IN WIN_NT_BLOCK_IO_PRIVATE
*Private
,
1044 IN INT64 DistanceToMove
,
1045 OUT UINT64
*NewFilePointer
,
1050 This function extends the capability of SetFilePointer to accept 64 bit parameters
1053 // TODO: function comment is missing 'Routine Description:'
1054 // TODO: function comment is missing 'Arguments:'
1055 // TODO: function comment is missing 'Returns:'
1056 // TODO: Private - add argument and description to function comment
1057 // TODO: DistanceToMove - add argument and description to function comment
1058 // TODO: NewFilePointer - add argument and description to function comment
1059 // TODO: MoveMethod - add argument and description to function comment
1062 LARGE_INTEGER LargeInt
;
1065 LargeInt
.QuadPart
= DistanceToMove
;
1066 Status
= EFI_SUCCESS
;
1068 LargeInt
.LowPart
= Private
->WinNtThunk
->SetFilePointer (
1075 if (LargeInt
.LowPart
== -1 &&
1076 (ErrorCode
= Private
->WinNtThunk
->GetLastError ()) != NO_ERROR
) {
1077 Status
= EFI_INVALID_PARAMETER
;
1080 if (NewFilePointer
!= NULL
) {
1081 *NewFilePointer
= LargeInt
.QuadPart
;