3 Copyright (c) 2006 - 2007, 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 This following section documents the envirnoment variables for the Win NT
19 build. These variables are used to define the (virtual) hardware
20 configuration of the NT environment
22 A ! can be used to seperate multiple instances in a variable. Each
23 instance represents a seperate hardware device.
25 EFI_WIN_NT_PHYSICAL_DISKS - maps to drives on your system
26 EFI_WIN_NT_VIRTUAL_DISKS - maps to a device emulated by a file
27 EFI_WIN_NT_FILE_SYSTEM - mouts a directory as a file system
28 EFI_WIN_NT_CONSOLE - make a logical comand line window (only one!)
29 EFI_WIN_NT_UGA - Builds UGA Windows of Width and Height
30 EFI_WIN_NT_SERIAL_PORT - maps physical serial ports
32 <F>ixed - Fixed disk like a hard drive.
33 <R>emovable - Removable media like a floppy or CD-ROM.
34 Read <O>nly - Write protected device.
35 Read <W>rite - Read write device.
36 <block count> - Decimal number of blocks a device supports.
37 <block size> - Decimal number of bytes per block.
39 NT envirnonment variable contents. '<' and '>' are not part of the variable,
40 they are just used to make this help more readable. There should be no
41 spaces between the ';'. Extra spaces will break the variable. A '!' is
42 used to seperate multiple devices in a variable.
44 EFI_WIN_NT_VIRTUAL_DISKS =
45 <F | R><O | W>;<block count>;<block size>[!...]
47 EFI_WIN_NT_PHYSICAL_DISKS =
48 <drive letter>:<F | R><O | W>;<block count>;<block size>[!...]
50 Virtual Disks: These devices use a file to emulate a hard disk or removable
53 Thus a 20 MB emulated hard drive would look like:
54 EFI_WIN_NT_VIRTUAL_DISKS=FW;40960;512
56 A 1.44MB emulated floppy with a block size of 1024 would look like:
57 EFI_WIN_NT_VIRTUAL_DISKS=RW;1440;1024
59 Physical Disks: These devices use NT to open a real device in your system
61 Thus a 120 MB floppy would look like:
62 EFI_WIN_NT_PHYSICAL_DISKS=B:RW;245760;512
64 Thus a standard CD-ROM floppy would look like:
65 EFI_WIN_NT_PHYSICAL_DISKS=Z:RO;307200;2048
67 EFI_WIN_NT_FILE_SYSTEM =
68 <directory path>[!...]
70 Mounting the two directories C:\FOO and C:\BAR would look like:
71 EFI_WIN_NT_FILE_SYSTEM=c:\foo!c:\bar
76 Declaring a text console window with the title "My EFI Console" woild look like:
77 EFI_WIN_NT_CONSOLE=My EFI Console
80 <width> <height>[!...]
82 Declaring a two UGA windows with resolutions of 800x600 and 1024x768 would look like:
83 Example : EFI_WIN_NT_UGA=800 600!1024 768
85 EFI_WIN_NT_SERIAL_PORT =
88 Declaring two serial ports on COM1 and COM2 would look like:
89 Example : EFI_WIN_NT_SERIAL_PORT=COM1!COM2
91 EFI_WIN_NT_PASS_THROUGH =
92 <BaseAddress>;<Bus#>;<Device#>;<Function#>
94 Declaring a base address of 0xE0000000 (used for PCI Express devices)
95 and having NT32 talk to a device located at bus 0, device 1, function 0:
96 Example : EFI_WIN_NT_PASS_THROUGH=E000000;0;1;0
101 // The package level header files this module uses
104 #include <WinNtDxe.h>
106 // The protocols, PPI and GUID defintions for this module
108 #include <Protocol/WinNtThunk.h>
109 #include <Protocol/WinNtIo.h>
110 #include <Protocol/ComponentName.h>
111 #include <Protocol/DriverBinding.h>
112 #include <Protocol/DevicePath.h>
114 // The Library classes this module consumes
116 #include <Library/DebugLib.h>
117 #include <Library/BaseLib.h>
118 #include <Library/UefiDriverEntryPoint.h>
119 #include <Library/UefiLib.h>
120 #include <Library/PcdLib.h>
121 #include <Library/BaseMemoryLib.h>
122 #include <Library/UefiBootServicesTableLib.h>
123 #include <Library/DevicePathLib.h>
124 #include <Library/MemoryAllocationLib.h>
126 #include "WinNtBusDriver.h"
128 extern EFI_GUID gWinNtBusDriverGuid
;
130 // DriverBinding protocol global
132 EFI_DRIVER_BINDING_PROTOCOL gWinNtBusDriverBinding
= {
133 WinNtBusDriverBindingSupported
,
134 WinNtBusDriverBindingStart
,
135 WinNtBusDriverBindingStop
,
141 #define NT_PCD_ARRAY_SIZE (sizeof(mPcdEnvironment)/sizeof(NT_PCD_ENTRY))
144 // Table to map NT Environment variable to the GUID that should be in
147 static NT_PCD_ENTRY mPcdEnvironment
[] = {
148 PcdToken(PcdWinNtConsole
), &gEfiWinNtConsoleGuid
,
149 PcdToken(PcdWinNtGop
), &gEfiWinNtGopGuid
,
150 PcdToken(PcdWinNtSerialPort
), &gEfiWinNtSerialPortGuid
,
151 PcdToken(PcdWinNtFileSystem
), &gEfiWinNtFileSystemGuid
,
152 PcdToken(PcdWinNtVirtualDisk
), &gEfiWinNtVirtualDisksGuid
,
153 PcdToken(PcdWinNtPhysicalDisk
), &gEfiWinNtPhysicalDisksGuid
157 The user Entry Point for module WinNtBusDriver. The user code starts with this function.
159 @param[in] ImageHandle The firmware allocated handle for the EFI image.
160 @param[in] SystemTable A pointer to the EFI System Table.
162 @retval EFI_SUCCESS The entry point is executed successfully.
163 @retval other Some error occurs when executing this entry point.
168 InitializeWinNtBusDriver(
169 IN EFI_HANDLE ImageHandle
,
170 IN EFI_SYSTEM_TABLE
*SystemTable
176 // Install driver model protocol(s).
178 Status
= EfiLibInstallAllDriverProtocols (
181 &gWinNtBusDriverBinding
,
183 &gWinNtBusDriverComponentName
,
187 ASSERT_EFI_ERROR (Status
);
200 Buffer
= AllocatePool (Size
);
201 ASSERT (Buffer
!= NULL
);
209 WinNtBusDriverBindingSupported (
210 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
211 IN EFI_HANDLE ControllerHandle
,
212 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
225 // TODO: This - add argument and description to function comment
226 // TODO: ControllerHandle - add argument and description to function comment
227 // TODO: RemainingDevicePath - add argument and description to function comment
228 // TODO: EFI_UNSUPPORTED - add return value to function comment
229 // TODO: EFI_UNSUPPORTED - add return value to function comment
230 // TODO: EFI_SUCCESS - add return value to function comment
231 // TODO: EFI_SUCCESS - add return value to function comment
234 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
235 EFI_WIN_NT_THUNK_PROTOCOL
*WinNtThunk
;
239 // Check the contents of the first Device Path Node of RemainingDevicePath to make sure
240 // it is a legal Device Path Node for this bus driver's children.
242 if (RemainingDevicePath
!= NULL
) {
243 if (RemainingDevicePath
->Type
!= HARDWARE_DEVICE_PATH
||
244 RemainingDevicePath
->SubType
!= HW_VENDOR_DP
||
245 DevicePathNodeLength(RemainingDevicePath
) != sizeof(WIN_NT_VENDOR_DEVICE_PATH_NODE
)) {
246 return EFI_UNSUPPORTED
;
249 for (Index
= 0; Index
< NT_PCD_ARRAY_SIZE
; Index
++) {
250 if (CompareGuid (&((VENDOR_DEVICE_PATH
*) RemainingDevicePath
)->Guid
, mPcdEnvironment
[Index
].DevicePathGuid
)) {
255 if (Index
>= NT_PCD_ARRAY_SIZE
) {
256 return EFI_UNSUPPORTED
;
261 // Open the IO Abstraction(s) needed to perform the supported test
263 Status
= gBS
->OpenProtocol (
265 &gEfiDevicePathProtocolGuid
,
267 This
->DriverBindingHandle
,
269 EFI_OPEN_PROTOCOL_BY_DRIVER
271 if (Status
== EFI_ALREADY_STARTED
) {
275 if (EFI_ERROR (Status
)) {
281 &gEfiDevicePathProtocolGuid
,
282 This
->DriverBindingHandle
,
286 Status
= gBS
->OpenProtocol (
288 &gEfiWinNtThunkProtocolGuid
,
290 This
->DriverBindingHandle
,
292 EFI_OPEN_PROTOCOL_BY_DRIVER
294 if (Status
== EFI_ALREADY_STARTED
) {
298 if (EFI_ERROR (Status
)) {
303 // Since we call through WinNtThunk we need to make sure it's valid
305 Status
= EFI_SUCCESS
;
306 if (WinNtThunk
->Signature
!= EFI_WIN_NT_THUNK_PROTOCOL_SIGNATURE
) {
307 Status
= EFI_UNSUPPORTED
;
311 // Close the I/O Abstraction(s) used to perform the supported test
315 &gEfiWinNtThunkProtocolGuid
,
316 This
->DriverBindingHandle
,
325 WinNtBusDriverBindingStart (
326 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
327 IN EFI_HANDLE ControllerHandle
,
328 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
341 // TODO: This - add argument and description to function comment
342 // TODO: ControllerHandle - add argument and description to function comment
343 // TODO: RemainingDevicePath - add argument and description to function comment
344 // TODO: EFI_OUT_OF_RESOURCES - add return value to function comment
345 // TODO: EFI_OUT_OF_RESOURCES - add return value to function comment
346 // TODO: EFI_SUCCESS - add return value to function comment
349 EFI_STATUS InstallStatus
;
350 EFI_WIN_NT_THUNK_PROTOCOL
*WinNtThunk
;
351 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
352 WIN_NT_BUS_DEVICE
*WinNtBusDevice
;
353 WIN_NT_IO_DEVICE
*WinNtDevice
;
359 UINT16 ComponentName
[MAX_NT_ENVIRNMENT_VARIABLE_LENGTH
];
360 WIN_NT_VENDOR_DEVICE_PATH_NODE
*Node
;
361 BOOLEAN CreateDevice
;
366 Status
= EFI_UNSUPPORTED
;
369 // Grab the protocols we need
371 Status
= gBS
->OpenProtocol (
373 &gEfiDevicePathProtocolGuid
,
375 This
->DriverBindingHandle
,
377 EFI_OPEN_PROTOCOL_BY_DRIVER
379 if (EFI_ERROR (Status
) && Status
!= EFI_ALREADY_STARTED
) {
383 Status
= gBS
->OpenProtocol (
385 &gEfiWinNtThunkProtocolGuid
,
387 This
->DriverBindingHandle
,
389 EFI_OPEN_PROTOCOL_BY_DRIVER
391 if (EFI_ERROR (Status
) && Status
!= EFI_ALREADY_STARTED
) {
395 if (Status
!= EFI_ALREADY_STARTED
) {
396 WinNtBusDevice
= AllocatePool (sizeof (WIN_NT_BUS_DEVICE
));
397 if (WinNtBusDevice
== NULL
) {
398 return EFI_OUT_OF_RESOURCES
;
401 WinNtBusDevice
->Signature
= WIN_NT_BUS_DEVICE_SIGNATURE
;
402 WinNtBusDevice
->ControllerNameTable
= NULL
;
406 gWinNtBusDriverComponentName
.SupportedLanguages
,
407 &WinNtBusDevice
->ControllerNameTable
,
408 L
"Windows Bus Controller"
411 Status
= gBS
->InstallMultipleProtocolInterfaces (
413 &gWinNtBusDriverGuid
,
417 if (EFI_ERROR (Status
)) {
418 FreeUnicodeStringTable (WinNtBusDevice
->ControllerNameTable
);
419 FreePool (WinNtBusDevice
);
425 // Loop on the Variable list. Parse each variable to produce a set of handles that
426 // represent virtual hardware devices.
428 InstallStatus
= EFI_NOT_FOUND
;
429 for (Index
= 0; Index
< NT_PCD_ARRAY_SIZE
; Index
++) {
430 PcdTempStr
= (VOID
*)LibPcdGetPtr (mPcdEnvironment
[Index
].Token
);
431 ASSERT (PcdTempStr
!= NULL
);
433 TempStrSize
= StrLen (PcdTempStr
);
434 TempStr
= AllocateMemory ((TempStrSize
* sizeof (CHAR16
)) + 1);
435 StrCpy (TempStr
, PcdTempStr
);
437 StartString
= TempStr
;
440 // Parse the envirnment variable into sub strings using '!' as a delimator.
441 // Each substring needs it's own handle to be added to the system. This code
442 // does not understand the sub string. Thats the device drivers job.
445 while (*StartString
!= '\0') {
448 // Find the end of the sub string
450 SubString
= StartString
;
451 while (*SubString
!= '\0' && *SubString
!= '!') {
455 if (*SubString
== '!') {
457 // Replace token with '\0' to make sub strings. If this is the end
458 // of the string SubString will already point to NULL.
465 if (RemainingDevicePath
!= NULL
) {
466 CreateDevice
= FALSE
;
467 Node
= (WIN_NT_VENDOR_DEVICE_PATH_NODE
*) RemainingDevicePath
;
468 if (Node
->VendorDevicePath
.Header
.Type
== HARDWARE_DEVICE_PATH
&&
469 Node
->VendorDevicePath
.Header
.SubType
== HW_VENDOR_DP
&&
470 DevicePathNodeLength (&Node
->VendorDevicePath
.Header
) == sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE
)
472 if (CompareGuid (&Node
->VendorDevicePath
.Guid
, mPcdEnvironment
[Index
].DevicePathGuid
) &&
473 Node
->Instance
== Count
483 // Allocate instance structure, and fill in parent information.
485 WinNtDevice
= AllocateMemory (sizeof (WIN_NT_IO_DEVICE
));
486 if (WinNtDevice
== NULL
) {
487 return EFI_OUT_OF_RESOURCES
;
490 WinNtDevice
->Handle
= NULL
;
491 WinNtDevice
->ControllerHandle
= ControllerHandle
;
492 WinNtDevice
->ParentDevicePath
= ParentDevicePath
;
494 WinNtDevice
->WinNtIo
.WinNtThunk
= WinNtThunk
;
497 // Plus 2 to account for the NULL at the end of the Unicode string
499 StringSize
= (UINTN
) ((UINT8
*) SubString
- (UINT8
*) StartString
) + sizeof (CHAR16
);
500 WinNtDevice
->WinNtIo
.EnvString
= AllocateMemory (StringSize
);
501 if (WinNtDevice
->WinNtIo
.EnvString
!= NULL
) {
502 CopyMem (WinNtDevice
->WinNtIo
.EnvString
, StartString
, StringSize
);
505 WinNtDevice
->ControllerNameTable
= NULL
;
507 WinNtThunk
->SPrintf (ComponentName
, sizeof (ComponentName
), L
"%s", WinNtDevice
->WinNtIo
.EnvString
);
509 WinNtDevice
->DevicePath
= WinNtBusCreateDevicePath (
511 mPcdEnvironment
[Index
].DevicePathGuid
,
514 if (WinNtDevice
->DevicePath
== NULL
) {
515 FreePool (WinNtDevice
);
516 return EFI_OUT_OF_RESOURCES
;
521 gWinNtBusDriverComponentName
.SupportedLanguages
,
522 &WinNtDevice
->ControllerNameTable
,
526 WinNtDevice
->WinNtIo
.TypeGuid
= mPcdEnvironment
[Index
].DevicePathGuid
;
527 WinNtDevice
->WinNtIo
.InstanceNumber
= Count
;
529 WinNtDevice
->Signature
= WIN_NT_IO_DEVICE_SIGNATURE
;
531 Status
= gBS
->InstallMultipleProtocolInterfaces (
532 &WinNtDevice
->Handle
,
533 &gEfiDevicePathProtocolGuid
,
534 WinNtDevice
->DevicePath
,
535 &gEfiWinNtIoProtocolGuid
,
536 &WinNtDevice
->WinNtIo
,
539 if (EFI_ERROR (Status
)) {
540 FreeUnicodeStringTable (WinNtDevice
->ControllerNameTable
);
541 FreePool (WinNtDevice
);
544 // Open For Child Device
546 Status
= gBS
->OpenProtocol (
548 &gEfiWinNtThunkProtocolGuid
,
550 This
->DriverBindingHandle
,
552 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
554 if (!EFI_ERROR (Status
)) {
555 InstallStatus
= EFI_SUCCESS
;
561 // Parse Next sub string. This will point to '\0' if we are at the end.
564 StartString
= SubString
;
576 WinNtBusDriverBindingStop (
577 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
578 IN EFI_HANDLE ControllerHandle
,
579 IN UINTN NumberOfChildren
,
580 IN EFI_HANDLE
*ChildHandleBuffer
593 // TODO: This - add argument and description to function comment
594 // TODO: ControllerHandle - add argument and description to function comment
595 // TODO: NumberOfChildren - add argument and description to function comment
596 // TODO: ChildHandleBuffer - add argument and description to function comment
597 // TODO: EFI_SUCCESS - add return value to function comment
598 // TODO: EFI_DEVICE_ERROR - add return value to function comment
599 // TODO: EFI_SUCCESS - add return value to function comment
603 BOOLEAN AllChildrenStopped
;
604 EFI_WIN_NT_IO_PROTOCOL
*WinNtIo
;
605 WIN_NT_BUS_DEVICE
*WinNtBusDevice
;
606 WIN_NT_IO_DEVICE
*WinNtDevice
;
607 EFI_WIN_NT_THUNK_PROTOCOL
*WinNtThunk
;
610 // Complete all outstanding transactions to Controller.
611 // Don't allow any new transaction to Controller to be started.
614 if (NumberOfChildren
== 0) {
616 // Close the bus driver
618 Status
= gBS
->OpenProtocol (
620 &gWinNtBusDriverGuid
,
622 This
->DriverBindingHandle
,
624 EFI_OPEN_PROTOCOL_GET_PROTOCOL
626 if (EFI_ERROR (Status
)) {
630 gBS
->UninstallMultipleProtocolInterfaces (
632 &gWinNtBusDriverGuid
,
637 FreeUnicodeStringTable (WinNtBusDevice
->ControllerNameTable
);
639 FreePool (WinNtBusDevice
);
643 &gEfiWinNtThunkProtocolGuid
,
644 This
->DriverBindingHandle
,
650 &gEfiDevicePathProtocolGuid
,
651 This
->DriverBindingHandle
,
657 AllChildrenStopped
= TRUE
;
659 for (Index
= 0; Index
< NumberOfChildren
; Index
++) {
661 Status
= gBS
->OpenProtocol (
662 ChildHandleBuffer
[Index
],
663 &gEfiWinNtIoProtocolGuid
,
665 This
->DriverBindingHandle
,
667 EFI_OPEN_PROTOCOL_GET_PROTOCOL
669 if (!EFI_ERROR (Status
)) {
671 WinNtDevice
= WIN_NT_IO_DEVICE_FROM_THIS (WinNtIo
);
673 Status
= gBS
->CloseProtocol (
675 &gEfiWinNtThunkProtocolGuid
,
676 This
->DriverBindingHandle
,
680 Status
= gBS
->UninstallMultipleProtocolInterfaces (
682 &gEfiDevicePathProtocolGuid
,
683 WinNtDevice
->DevicePath
,
684 &gEfiWinNtIoProtocolGuid
,
685 &WinNtDevice
->WinNtIo
,
689 if (EFI_ERROR (Status
)) {
692 &gEfiWinNtThunkProtocolGuid
,
693 (VOID
**) &WinNtThunk
,
694 This
->DriverBindingHandle
,
696 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
700 // Close the child handle
702 FreeUnicodeStringTable (WinNtDevice
->ControllerNameTable
);
703 FreePool (WinNtDevice
);
707 if (EFI_ERROR (Status
)) {
708 AllChildrenStopped
= FALSE
;
712 if (!AllChildrenStopped
) {
713 return EFI_DEVICE_ERROR
;
719 EFI_DEVICE_PATH_PROTOCOL
*
720 WinNtBusCreateDevicePath (
721 IN EFI_DEVICE_PATH_PROTOCOL
*RootDevicePath
,
723 IN UINT16 InstanceNumber
728 Create a device path node using Guid and InstanceNumber and append it to
729 the passed in RootDevicePath
732 RootDevicePath - Root of the device path to return.
734 Guid - GUID to use in vendor device path node.
736 InstanceNumber - Instance number to use in the vendor device path. This
737 argument is needed to make sure each device path is unique.
741 EFI_DEVICE_PATH_PROTOCOL
745 WIN_NT_VENDOR_DEVICE_PATH_NODE DevicePath
;
747 DevicePath
.VendorDevicePath
.Header
.Type
= HARDWARE_DEVICE_PATH
;
748 DevicePath
.VendorDevicePath
.Header
.SubType
= HW_VENDOR_DP
;
749 SetDevicePathNodeLength (&DevicePath
.VendorDevicePath
.Header
, sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE
));
752 // The GUID defines the Class
754 CopyMem (&DevicePath
.VendorDevicePath
.Guid
, Guid
, sizeof (EFI_GUID
));
757 // Add an instance number so we can make sure there are no Device Path
760 DevicePath
.Instance
= InstanceNumber
;
762 return AppendDevicePathNode (
764 (EFI_DEVICE_PATH_PROTOCOL
*) &DevicePath