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 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
100 #include "WinNtBusDriver.h"
101 //#include "PciHostBridge.h"
104 // Define GUID for the WinNt Bus Driver
106 static EFI_GUID gWinNtBusDriverGuid
= {
107 0x419f582, 0x625, 0x4531, 0x8a, 0x33, 0x85, 0xa9, 0x96, 0x5c, 0x95, 0xbc
111 // DriverBinding protocol global
113 EFI_DRIVER_BINDING_PROTOCOL gWinNtBusDriverBinding
= {
114 WinNtBusDriverBindingSupported
,
115 WinNtBusDriverBindingStart
,
116 WinNtBusDriverBindingStop
,
122 #define NT_PCD_ARRAY_SIZE (sizeof(mPcdEnvironment)/sizeof(NT_PCD_ENTRY))
125 // Table to map NT Environment variable to the GUID that should be in
128 static NT_PCD_ENTRY mPcdEnvironment
[] = {
129 PcdToken(PcdWinNtConsole
), &gEfiWinNtConsoleGuid
,
130 PcdToken(PcdWinNtUga
), &gEfiWinNtUgaGuid
,
131 PcdToken(PcdWinNtSerialPort
), &gEfiWinNtSerialPortGuid
,
132 PcdToken(PcdWinNtFileSystem
), &gEfiWinNtFileSystemGuid
,
133 PcdToken(PcdWinNtVirtualDisk
), &gEfiWinNtVirtualDisksGuid
,
134 PcdToken(PcdWinNtPhysicalDisk
), &gEfiWinNtPhysicalDisksGuid
,
135 PcdToken(PcdWinNtCpuModel
), &gEfiWinNtCPUModelGuid
,
136 PcdToken(PcdWinNtCpuSpeed
), &gEfiWinNtCPUSpeedGuid
,
137 PcdToken(PcdWinNtMemorySize
), &gEfiWinNtMemoryGuid
148 Status
= gBS
->AllocatePool (
153 if (EFI_ERROR (Status
)) {
163 WinNtBusDriverBindingSupported (
164 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
165 IN EFI_HANDLE ControllerHandle
,
166 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
179 // TODO: This - add argument and description to function comment
180 // TODO: ControllerHandle - add argument and description to function comment
181 // TODO: RemainingDevicePath - add argument and description to function comment
182 // TODO: EFI_UNSUPPORTED - add return value to function comment
183 // TODO: EFI_UNSUPPORTED - add return value to function comment
184 // TODO: EFI_SUCCESS - add return value to function comment
185 // TODO: EFI_SUCCESS - add return value to function comment
188 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
189 EFI_WIN_NT_THUNK_PROTOCOL
*WinNtThunk
;
193 // Check the contents of the first Device Path Node of RemainingDevicePath to make sure
194 // it is a legal Device Path Node for this bus driver's children.
196 if (RemainingDevicePath
!= NULL
) {
197 if (RemainingDevicePath
->Type
!= HARDWARE_DEVICE_PATH
||
198 RemainingDevicePath
->SubType
!= HW_VENDOR_DP
||
199 DevicePathNodeLength(RemainingDevicePath
) != sizeof(WIN_NT_VENDOR_DEVICE_PATH_NODE
)) {
200 return EFI_UNSUPPORTED
;
203 for (Index
= 0; Index
< NT_PCD_ARRAY_SIZE
; Index
++) {
204 if (CompareGuid (&((VENDOR_DEVICE_PATH
*) RemainingDevicePath
)->Guid
, mPcdEnvironment
[Index
].DevicePathGuid
)) {
209 if (Index
>= NT_PCD_ARRAY_SIZE
) {
210 return EFI_UNSUPPORTED
;
215 // Open the IO Abstraction(s) needed to perform the supported test
217 Status
= gBS
->OpenProtocol (
219 &gEfiDevicePathProtocolGuid
,
221 This
->DriverBindingHandle
,
223 EFI_OPEN_PROTOCOL_BY_DRIVER
225 if (Status
== EFI_ALREADY_STARTED
) {
229 if (EFI_ERROR (Status
)) {
235 &gEfiDevicePathProtocolGuid
,
236 This
->DriverBindingHandle
,
240 Status
= gBS
->OpenProtocol (
242 &gEfiWinNtThunkProtocolGuid
,
244 This
->DriverBindingHandle
,
246 EFI_OPEN_PROTOCOL_BY_DRIVER
248 if (Status
== EFI_ALREADY_STARTED
) {
252 if (EFI_ERROR (Status
)) {
257 // Since we call through WinNtThunk we need to make sure it's valid
259 Status
= EFI_SUCCESS
;
260 if (WinNtThunk
->Signature
!= EFI_WIN_NT_THUNK_PROTOCOL_SIGNATURE
) {
261 Status
= EFI_UNSUPPORTED
;
265 // Close the I/O Abstraction(s) used to perform the supported test
269 &gEfiWinNtThunkProtocolGuid
,
270 This
->DriverBindingHandle
,
279 WinNtBusDriverBindingStart (
280 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
281 IN EFI_HANDLE ControllerHandle
,
282 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
295 // TODO: This - add argument and description to function comment
296 // TODO: ControllerHandle - add argument and description to function comment
297 // TODO: RemainingDevicePath - add argument and description to function comment
298 // TODO: EFI_OUT_OF_RESOURCES - add return value to function comment
299 // TODO: EFI_OUT_OF_RESOURCES - add return value to function comment
300 // TODO: EFI_SUCCESS - add return value to function comment
303 EFI_STATUS InstallStatus
;
304 EFI_WIN_NT_THUNK_PROTOCOL
*WinNtThunk
;
305 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
306 WIN_NT_BUS_DEVICE
*WinNtBusDevice
;
307 WIN_NT_IO_DEVICE
*WinNtDevice
;
313 UINT16 ComponentName
[MAX_NT_ENVIRNMENT_VARIABLE_LENGTH
];
314 WIN_NT_VENDOR_DEVICE_PATH_NODE
*Node
;
315 BOOLEAN CreateDevice
;
321 // Test Feature Set and Binary Patchable Case
323 if (FeaturePcdGet (PcdWinNtFeatureFlag1
)) {
324 TempStrSize
= PatchPcdGet32(PcdWinNtBinaryPatch1
) + PatchPcdGet32(PcdWinNtBinaryPatch2
);
329 // Test Dynamic and DynamicEx
330 // (Please add PcdWinNtConsole in "WinNtBusDriver.inf" before enable this code!!!)
332 PcdTempStr
= PcdGetPtr (PcdWinNtConsole
);
336 // Test Dynamic Set and Dynamic Set Ex
338 PcdSet32 (PcdWinNtDynamicUINT32
, 2006);
340 Status
= EFI_UNSUPPORTED
;
343 // Grab the protocols we need
345 Status
= gBS
->OpenProtocol (
347 &gEfiDevicePathProtocolGuid
,
349 This
->DriverBindingHandle
,
351 EFI_OPEN_PROTOCOL_BY_DRIVER
353 if (EFI_ERROR (Status
) && Status
!= EFI_ALREADY_STARTED
) {
357 Status
= gBS
->OpenProtocol (
359 &gEfiWinNtThunkProtocolGuid
,
361 This
->DriverBindingHandle
,
363 EFI_OPEN_PROTOCOL_BY_DRIVER
365 if (EFI_ERROR (Status
) && Status
!= EFI_ALREADY_STARTED
) {
369 if (Status
!= EFI_ALREADY_STARTED
) {
370 Status
= gBS
->AllocatePool (
372 sizeof (WIN_NT_BUS_DEVICE
),
373 (VOID
*) &WinNtBusDevice
375 if (EFI_ERROR (Status
)) {
379 WinNtBusDevice
->Signature
= WIN_NT_BUS_DEVICE_SIGNATURE
;
380 WinNtBusDevice
->ControllerNameTable
= NULL
;
384 gWinNtBusDriverComponentName
.SupportedLanguages
,
385 &WinNtBusDevice
->ControllerNameTable
,
386 L
"Windows Bus Controller"
389 Status
= gBS
->InstallMultipleProtocolInterfaces (
391 &gWinNtBusDriverGuid
,
395 if (EFI_ERROR (Status
)) {
396 FreeUnicodeStringTable (WinNtBusDevice
->ControllerNameTable
);
397 gBS
->FreePool (WinNtBusDevice
);
403 // Loop on the Variable list. Parse each variable to produce a set of handles that
404 // represent virtual hardware devices.
406 InstallStatus
= EFI_NOT_FOUND
;
407 for (Index
= 0; Index
< NT_PCD_ARRAY_SIZE
; Index
++) {
408 PcdTempStr
= (VOID
*)LibPcdGetPtr (mPcdEnvironment
[Index
].Token
);
409 ASSERT (PcdTempStr
!= NULL
);
411 TempStrSize
= StrLen (PcdTempStr
);
412 TempStr
= AllocateMemory ((TempStrSize
* sizeof (CHAR16
)) + 1);
413 StrCpy (TempStr
, PcdTempStr
);
415 StartString
= TempStr
;
418 // Parse the envirnment variable into sub strings using '!' as a delimator.
419 // Each substring needs it's own handle to be added to the system. This code
420 // does not understand the sub string. Thats the device drivers job.
423 while (*StartString
!= '\0') {
426 // Find the end of the sub string
428 SubString
= StartString
;
429 while (*SubString
!= '\0' && *SubString
!= '!') {
433 if (*SubString
== '!') {
435 // Replace token with '\0' to make sub strings. If this is the end
436 // of the string SubString will already point to NULL.
443 if (RemainingDevicePath
!= NULL
) {
444 CreateDevice
= FALSE
;
445 Node
= (WIN_NT_VENDOR_DEVICE_PATH_NODE
*) RemainingDevicePath
;
446 if (Node
->VendorDevicePath
.Header
.Type
== HARDWARE_DEVICE_PATH
&&
447 Node
->VendorDevicePath
.Header
.SubType
== HW_VENDOR_DP
&&
448 DevicePathNodeLength (&Node
->VendorDevicePath
.Header
) == sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE
)
450 if (CompareGuid (&Node
->VendorDevicePath
.Guid
, mPcdEnvironment
[Index
].DevicePathGuid
) &&
451 Node
->Instance
== Count
461 // Allocate instance structure, and fill in parent information.
463 WinNtDevice
= AllocateMemory (sizeof (WIN_NT_IO_DEVICE
));
464 if (WinNtDevice
== NULL
) {
465 return EFI_OUT_OF_RESOURCES
;
468 WinNtDevice
->Handle
= NULL
;
469 WinNtDevice
->ControllerHandle
= ControllerHandle
;
470 WinNtDevice
->ParentDevicePath
= ParentDevicePath
;
472 WinNtDevice
->WinNtIo
.WinNtThunk
= WinNtThunk
;
475 // Plus 2 to account for the NULL at the end of the Unicode string
477 StringSize
= (UINTN
) ((UINT8
*) SubString
- (UINT8
*) StartString
) + sizeof (CHAR16
);
478 WinNtDevice
->WinNtIo
.EnvString
= AllocateMemory (StringSize
);
479 if (WinNtDevice
->WinNtIo
.EnvString
!= NULL
) {
480 CopyMem (WinNtDevice
->WinNtIo
.EnvString
, StartString
, StringSize
);
483 WinNtDevice
->ControllerNameTable
= NULL
;
485 WinNtThunk
->SPrintf (ComponentName
, L
"%s", WinNtDevice
->WinNtIo
.EnvString
);
487 WinNtDevice
->DevicePath
= WinNtBusCreateDevicePath (
489 mPcdEnvironment
[Index
].DevicePathGuid
,
492 if (WinNtDevice
->DevicePath
== NULL
) {
493 gBS
->FreePool (WinNtDevice
);
494 return EFI_OUT_OF_RESOURCES
;
499 gWinNtBusDriverComponentName
.SupportedLanguages
,
500 &WinNtDevice
->ControllerNameTable
,
504 WinNtDevice
->WinNtIo
.TypeGuid
= mPcdEnvironment
[Index
].DevicePathGuid
;
505 WinNtDevice
->WinNtIo
.InstanceNumber
= Count
;
507 WinNtDevice
->Signature
= WIN_NT_IO_DEVICE_SIGNATURE
;
509 Status
= gBS
->InstallMultipleProtocolInterfaces (
510 &WinNtDevice
->Handle
,
511 &gEfiDevicePathProtocolGuid
,
512 WinNtDevice
->DevicePath
,
513 &gEfiWinNtIoProtocolGuid
,
514 &WinNtDevice
->WinNtIo
,
517 if (EFI_ERROR (Status
)) {
518 FreeUnicodeStringTable (WinNtDevice
->ControllerNameTable
);
519 gBS
->FreePool (WinNtDevice
);
522 // Open For Child Device
524 Status
= gBS
->OpenProtocol (
526 &gEfiWinNtThunkProtocolGuid
,
528 This
->DriverBindingHandle
,
530 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
532 if (!EFI_ERROR (Status
)) {
533 InstallStatus
= EFI_SUCCESS
;
539 // Parse Next sub string. This will point to '\0' if we are at the end.
542 StartString
= SubString
;
545 gBS
->FreePool (TempStr
);
554 WinNtBusDriverBindingStop (
555 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
556 IN EFI_HANDLE ControllerHandle
,
557 IN UINTN NumberOfChildren
,
558 IN EFI_HANDLE
*ChildHandleBuffer
571 // TODO: This - add argument and description to function comment
572 // TODO: ControllerHandle - add argument and description to function comment
573 // TODO: NumberOfChildren - add argument and description to function comment
574 // TODO: ChildHandleBuffer - add argument and description to function comment
575 // TODO: EFI_SUCCESS - add return value to function comment
576 // TODO: EFI_DEVICE_ERROR - add return value to function comment
577 // TODO: EFI_SUCCESS - add return value to function comment
581 BOOLEAN AllChildrenStopped
;
582 EFI_WIN_NT_IO_PROTOCOL
*WinNtIo
;
583 WIN_NT_BUS_DEVICE
*WinNtBusDevice
;
584 WIN_NT_IO_DEVICE
*WinNtDevice
;
585 EFI_WIN_NT_THUNK_PROTOCOL
*WinNtThunk
;
588 // Complete all outstanding transactions to Controller.
589 // Don't allow any new transaction to Controller to be started.
592 if (NumberOfChildren
== 0) {
594 // Close the bus driver
596 Status
= gBS
->OpenProtocol (
598 &gWinNtBusDriverGuid
,
600 This
->DriverBindingHandle
,
602 EFI_OPEN_PROTOCOL_GET_PROTOCOL
604 if (EFI_ERROR (Status
)) {
608 gBS
->UninstallMultipleProtocolInterfaces (
610 &gWinNtBusDriverGuid
,
615 FreeUnicodeStringTable (WinNtBusDevice
->ControllerNameTable
);
617 gBS
->FreePool (WinNtBusDevice
);
621 &gEfiWinNtThunkProtocolGuid
,
622 This
->DriverBindingHandle
,
628 &gEfiDevicePathProtocolGuid
,
629 This
->DriverBindingHandle
,
635 AllChildrenStopped
= TRUE
;
637 for (Index
= 0; Index
< NumberOfChildren
; Index
++) {
639 Status
= gBS
->OpenProtocol (
640 ChildHandleBuffer
[Index
],
641 &gEfiWinNtIoProtocolGuid
,
643 This
->DriverBindingHandle
,
645 EFI_OPEN_PROTOCOL_GET_PROTOCOL
647 if (!EFI_ERROR (Status
)) {
649 WinNtDevice
= WIN_NT_IO_DEVICE_FROM_THIS (WinNtIo
);
651 Status
= gBS
->CloseProtocol (
653 &gEfiWinNtThunkProtocolGuid
,
654 This
->DriverBindingHandle
,
658 Status
= gBS
->UninstallMultipleProtocolInterfaces (
660 &gEfiDevicePathProtocolGuid
,
661 WinNtDevice
->DevicePath
,
662 &gEfiWinNtIoProtocolGuid
,
663 &WinNtDevice
->WinNtIo
,
667 if (EFI_ERROR (Status
)) {
670 &gEfiWinNtThunkProtocolGuid
,
671 (VOID
**) &WinNtThunk
,
672 This
->DriverBindingHandle
,
674 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
678 // Close the child handle
680 FreeUnicodeStringTable (WinNtDevice
->ControllerNameTable
);
681 gBS
->FreePool (WinNtDevice
);
685 if (EFI_ERROR (Status
)) {
686 AllChildrenStopped
= FALSE
;
690 if (!AllChildrenStopped
) {
691 return EFI_DEVICE_ERROR
;
697 EFI_DEVICE_PATH_PROTOCOL
*
698 WinNtBusCreateDevicePath (
699 IN EFI_DEVICE_PATH_PROTOCOL
*RootDevicePath
,
701 IN UINT16 InstanceNumber
706 Create a device path node using Guid and InstanceNumber and append it to
707 the passed in RootDevicePath
710 RootDevicePath - Root of the device path to return.
712 Guid - GUID to use in vendor device path node.
714 InstanceNumber - Instance number to use in the vendor device path. This
715 argument is needed to make sure each device path is unique.
719 EFI_DEVICE_PATH_PROTOCOL
723 WIN_NT_VENDOR_DEVICE_PATH_NODE DevicePath
;
725 DevicePath
.VendorDevicePath
.Header
.Type
= HARDWARE_DEVICE_PATH
;
726 DevicePath
.VendorDevicePath
.Header
.SubType
= HW_VENDOR_DP
;
727 SetDevicePathNodeLength (&DevicePath
.VendorDevicePath
.Header
, sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE
));
730 // The GUID defines the Class
732 CopyMem (&DevicePath
.VendorDevicePath
.Guid
, Guid
, sizeof (EFI_GUID
));
735 // Add an instance number so we can make sure there are no Device Path
738 DevicePath
.Instance
= InstanceNumber
;
740 return AppendDevicePathNode (
742 (EFI_DEVICE_PATH_PROTOCOL
*) &DevicePath