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
,
154 PcdToken(PcdWinNtCpuModel
), &gEfiWinNtCPUModelGuid
,
155 PcdToken(PcdWinNtCpuSpeed
), &gEfiWinNtCPUSpeedGuid
,
156 PcdToken(PcdWinNtMemorySize
), &gEfiWinNtMemoryGuid
160 The user Entry Point for module WinNtBusDriver. The user code starts with this function.
162 @param[in] ImageHandle The firmware allocated handle for the EFI image.
163 @param[in] SystemTable A pointer to the EFI System Table.
165 @retval EFI_SUCCESS The entry point is executed successfully.
166 @retval other Some error occurs when executing this entry point.
171 InitializeWinNtBusDriver(
172 IN EFI_HANDLE ImageHandle
,
173 IN EFI_SYSTEM_TABLE
*SystemTable
179 // Install driver model protocol(s).
181 Status
= EfiLibInstallAllDriverProtocols (
184 &gWinNtBusDriverBinding
,
186 &gWinNtBusDriverComponentName
,
190 ASSERT_EFI_ERROR (Status
);
203 Buffer
= AllocatePool (Size
);
204 ASSERT (Buffer
!= NULL
);
212 WinNtBusDriverBindingSupported (
213 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
214 IN EFI_HANDLE ControllerHandle
,
215 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
228 // TODO: This - add argument and description to function comment
229 // TODO: ControllerHandle - add argument and description to function comment
230 // TODO: RemainingDevicePath - add argument and description to function comment
231 // TODO: EFI_UNSUPPORTED - add return value to function comment
232 // TODO: EFI_UNSUPPORTED - add return value to function comment
233 // TODO: EFI_SUCCESS - add return value to function comment
234 // TODO: EFI_SUCCESS - add return value to function comment
237 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
238 EFI_WIN_NT_THUNK_PROTOCOL
*WinNtThunk
;
242 // Check the contents of the first Device Path Node of RemainingDevicePath to make sure
243 // it is a legal Device Path Node for this bus driver's children.
245 if (RemainingDevicePath
!= NULL
) {
246 if (RemainingDevicePath
->Type
!= HARDWARE_DEVICE_PATH
||
247 RemainingDevicePath
->SubType
!= HW_VENDOR_DP
||
248 DevicePathNodeLength(RemainingDevicePath
) != sizeof(WIN_NT_VENDOR_DEVICE_PATH_NODE
)) {
249 return EFI_UNSUPPORTED
;
252 for (Index
= 0; Index
< NT_PCD_ARRAY_SIZE
; Index
++) {
253 if (CompareGuid (&((VENDOR_DEVICE_PATH
*) RemainingDevicePath
)->Guid
, mPcdEnvironment
[Index
].DevicePathGuid
)) {
258 if (Index
>= NT_PCD_ARRAY_SIZE
) {
259 return EFI_UNSUPPORTED
;
264 // Open the IO Abstraction(s) needed to perform the supported test
266 Status
= gBS
->OpenProtocol (
268 &gEfiDevicePathProtocolGuid
,
270 This
->DriverBindingHandle
,
272 EFI_OPEN_PROTOCOL_BY_DRIVER
274 if (Status
== EFI_ALREADY_STARTED
) {
278 if (EFI_ERROR (Status
)) {
284 &gEfiDevicePathProtocolGuid
,
285 This
->DriverBindingHandle
,
289 Status
= gBS
->OpenProtocol (
291 &gEfiWinNtThunkProtocolGuid
,
293 This
->DriverBindingHandle
,
295 EFI_OPEN_PROTOCOL_BY_DRIVER
297 if (Status
== EFI_ALREADY_STARTED
) {
301 if (EFI_ERROR (Status
)) {
306 // Since we call through WinNtThunk we need to make sure it's valid
308 Status
= EFI_SUCCESS
;
309 if (WinNtThunk
->Signature
!= EFI_WIN_NT_THUNK_PROTOCOL_SIGNATURE
) {
310 Status
= EFI_UNSUPPORTED
;
314 // Close the I/O Abstraction(s) used to perform the supported test
318 &gEfiWinNtThunkProtocolGuid
,
319 This
->DriverBindingHandle
,
328 WinNtBusDriverBindingStart (
329 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
330 IN EFI_HANDLE ControllerHandle
,
331 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
344 // TODO: This - add argument and description to function comment
345 // TODO: ControllerHandle - add argument and description to function comment
346 // TODO: RemainingDevicePath - add argument and description to function comment
347 // TODO: EFI_OUT_OF_RESOURCES - add return value to function comment
348 // TODO: EFI_OUT_OF_RESOURCES - add return value to function comment
349 // TODO: EFI_SUCCESS - add return value to function comment
352 EFI_STATUS InstallStatus
;
353 EFI_WIN_NT_THUNK_PROTOCOL
*WinNtThunk
;
354 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
355 WIN_NT_BUS_DEVICE
*WinNtBusDevice
;
356 WIN_NT_IO_DEVICE
*WinNtDevice
;
362 UINT16 ComponentName
[MAX_NT_ENVIRNMENT_VARIABLE_LENGTH
];
363 WIN_NT_VENDOR_DEVICE_PATH_NODE
*Node
;
364 BOOLEAN CreateDevice
;
369 Status
= EFI_UNSUPPORTED
;
372 // Grab the protocols we need
374 Status
= gBS
->OpenProtocol (
376 &gEfiDevicePathProtocolGuid
,
378 This
->DriverBindingHandle
,
380 EFI_OPEN_PROTOCOL_BY_DRIVER
382 if (EFI_ERROR (Status
) && Status
!= EFI_ALREADY_STARTED
) {
386 Status
= gBS
->OpenProtocol (
388 &gEfiWinNtThunkProtocolGuid
,
390 This
->DriverBindingHandle
,
392 EFI_OPEN_PROTOCOL_BY_DRIVER
394 if (EFI_ERROR (Status
) && Status
!= EFI_ALREADY_STARTED
) {
398 if (Status
!= EFI_ALREADY_STARTED
) {
399 WinNtBusDevice
= AllocatePool (sizeof (WIN_NT_BUS_DEVICE
));
400 if (WinNtBusDevice
== NULL
) {
401 return EFI_OUT_OF_RESOURCES
;
404 WinNtBusDevice
->Signature
= WIN_NT_BUS_DEVICE_SIGNATURE
;
405 WinNtBusDevice
->ControllerNameTable
= NULL
;
409 gWinNtBusDriverComponentName
.SupportedLanguages
,
410 &WinNtBusDevice
->ControllerNameTable
,
411 L
"Windows Bus Controller"
414 Status
= gBS
->InstallMultipleProtocolInterfaces (
416 &gWinNtBusDriverGuid
,
420 if (EFI_ERROR (Status
)) {
421 FreeUnicodeStringTable (WinNtBusDevice
->ControllerNameTable
);
422 FreePool (WinNtBusDevice
);
428 // Loop on the Variable list. Parse each variable to produce a set of handles that
429 // represent virtual hardware devices.
431 InstallStatus
= EFI_NOT_FOUND
;
432 for (Index
= 0; Index
< NT_PCD_ARRAY_SIZE
; Index
++) {
433 PcdTempStr
= (VOID
*)LibPcdGetPtr (mPcdEnvironment
[Index
].Token
);
434 ASSERT (PcdTempStr
!= NULL
);
436 TempStrSize
= StrLen (PcdTempStr
);
437 TempStr
= AllocateMemory ((TempStrSize
* sizeof (CHAR16
)) + 1);
438 StrCpy (TempStr
, PcdTempStr
);
440 StartString
= TempStr
;
443 // Parse the envirnment variable into sub strings using '!' as a delimator.
444 // Each substring needs it's own handle to be added to the system. This code
445 // does not understand the sub string. Thats the device drivers job.
448 while (*StartString
!= '\0') {
451 // Find the end of the sub string
453 SubString
= StartString
;
454 while (*SubString
!= '\0' && *SubString
!= '!') {
458 if (*SubString
== '!') {
460 // Replace token with '\0' to make sub strings. If this is the end
461 // of the string SubString will already point to NULL.
468 if (RemainingDevicePath
!= NULL
) {
469 CreateDevice
= FALSE
;
470 Node
= (WIN_NT_VENDOR_DEVICE_PATH_NODE
*) RemainingDevicePath
;
471 if (Node
->VendorDevicePath
.Header
.Type
== HARDWARE_DEVICE_PATH
&&
472 Node
->VendorDevicePath
.Header
.SubType
== HW_VENDOR_DP
&&
473 DevicePathNodeLength (&Node
->VendorDevicePath
.Header
) == sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE
)
475 if (CompareGuid (&Node
->VendorDevicePath
.Guid
, mPcdEnvironment
[Index
].DevicePathGuid
) &&
476 Node
->Instance
== Count
486 // Allocate instance structure, and fill in parent information.
488 WinNtDevice
= AllocateMemory (sizeof (WIN_NT_IO_DEVICE
));
489 if (WinNtDevice
== NULL
) {
490 return EFI_OUT_OF_RESOURCES
;
493 WinNtDevice
->Handle
= NULL
;
494 WinNtDevice
->ControllerHandle
= ControllerHandle
;
495 WinNtDevice
->ParentDevicePath
= ParentDevicePath
;
497 WinNtDevice
->WinNtIo
.WinNtThunk
= WinNtThunk
;
500 // Plus 2 to account for the NULL at the end of the Unicode string
502 StringSize
= (UINTN
) ((UINT8
*) SubString
- (UINT8
*) StartString
) + sizeof (CHAR16
);
503 WinNtDevice
->WinNtIo
.EnvString
= AllocateMemory (StringSize
);
504 if (WinNtDevice
->WinNtIo
.EnvString
!= NULL
) {
505 CopyMem (WinNtDevice
->WinNtIo
.EnvString
, StartString
, StringSize
);
508 WinNtDevice
->ControllerNameTable
= NULL
;
510 WinNtThunk
->SPrintf (ComponentName
, sizeof (ComponentName
), L
"%s", WinNtDevice
->WinNtIo
.EnvString
);
512 WinNtDevice
->DevicePath
= WinNtBusCreateDevicePath (
514 mPcdEnvironment
[Index
].DevicePathGuid
,
517 if (WinNtDevice
->DevicePath
== NULL
) {
518 FreePool (WinNtDevice
);
519 return EFI_OUT_OF_RESOURCES
;
524 gWinNtBusDriverComponentName
.SupportedLanguages
,
525 &WinNtDevice
->ControllerNameTable
,
529 WinNtDevice
->WinNtIo
.TypeGuid
= mPcdEnvironment
[Index
].DevicePathGuid
;
530 WinNtDevice
->WinNtIo
.InstanceNumber
= Count
;
532 WinNtDevice
->Signature
= WIN_NT_IO_DEVICE_SIGNATURE
;
534 Status
= gBS
->InstallMultipleProtocolInterfaces (
535 &WinNtDevice
->Handle
,
536 &gEfiDevicePathProtocolGuid
,
537 WinNtDevice
->DevicePath
,
538 &gEfiWinNtIoProtocolGuid
,
539 &WinNtDevice
->WinNtIo
,
542 if (EFI_ERROR (Status
)) {
543 FreeUnicodeStringTable (WinNtDevice
->ControllerNameTable
);
544 FreePool (WinNtDevice
);
547 // Open For Child Device
549 Status
= gBS
->OpenProtocol (
551 &gEfiWinNtThunkProtocolGuid
,
553 This
->DriverBindingHandle
,
555 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
557 if (!EFI_ERROR (Status
)) {
558 InstallStatus
= EFI_SUCCESS
;
564 // Parse Next sub string. This will point to '\0' if we are at the end.
567 StartString
= SubString
;
579 WinNtBusDriverBindingStop (
580 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
581 IN EFI_HANDLE ControllerHandle
,
582 IN UINTN NumberOfChildren
,
583 IN EFI_HANDLE
*ChildHandleBuffer
596 // TODO: This - add argument and description to function comment
597 // TODO: ControllerHandle - add argument and description to function comment
598 // TODO: NumberOfChildren - add argument and description to function comment
599 // TODO: ChildHandleBuffer - add argument and description to function comment
600 // TODO: EFI_SUCCESS - add return value to function comment
601 // TODO: EFI_DEVICE_ERROR - add return value to function comment
602 // TODO: EFI_SUCCESS - add return value to function comment
606 BOOLEAN AllChildrenStopped
;
607 EFI_WIN_NT_IO_PROTOCOL
*WinNtIo
;
608 WIN_NT_BUS_DEVICE
*WinNtBusDevice
;
609 WIN_NT_IO_DEVICE
*WinNtDevice
;
610 EFI_WIN_NT_THUNK_PROTOCOL
*WinNtThunk
;
613 // Complete all outstanding transactions to Controller.
614 // Don't allow any new transaction to Controller to be started.
617 if (NumberOfChildren
== 0) {
619 // Close the bus driver
621 Status
= gBS
->OpenProtocol (
623 &gWinNtBusDriverGuid
,
625 This
->DriverBindingHandle
,
627 EFI_OPEN_PROTOCOL_GET_PROTOCOL
629 if (EFI_ERROR (Status
)) {
633 gBS
->UninstallMultipleProtocolInterfaces (
635 &gWinNtBusDriverGuid
,
640 FreeUnicodeStringTable (WinNtBusDevice
->ControllerNameTable
);
642 FreePool (WinNtBusDevice
);
646 &gEfiWinNtThunkProtocolGuid
,
647 This
->DriverBindingHandle
,
653 &gEfiDevicePathProtocolGuid
,
654 This
->DriverBindingHandle
,
660 AllChildrenStopped
= TRUE
;
662 for (Index
= 0; Index
< NumberOfChildren
; Index
++) {
664 Status
= gBS
->OpenProtocol (
665 ChildHandleBuffer
[Index
],
666 &gEfiWinNtIoProtocolGuid
,
668 This
->DriverBindingHandle
,
670 EFI_OPEN_PROTOCOL_GET_PROTOCOL
672 if (!EFI_ERROR (Status
)) {
674 WinNtDevice
= WIN_NT_IO_DEVICE_FROM_THIS (WinNtIo
);
676 Status
= gBS
->CloseProtocol (
678 &gEfiWinNtThunkProtocolGuid
,
679 This
->DriverBindingHandle
,
683 Status
= gBS
->UninstallMultipleProtocolInterfaces (
685 &gEfiDevicePathProtocolGuid
,
686 WinNtDevice
->DevicePath
,
687 &gEfiWinNtIoProtocolGuid
,
688 &WinNtDevice
->WinNtIo
,
692 if (EFI_ERROR (Status
)) {
695 &gEfiWinNtThunkProtocolGuid
,
696 (VOID
**) &WinNtThunk
,
697 This
->DriverBindingHandle
,
699 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
703 // Close the child handle
705 FreeUnicodeStringTable (WinNtDevice
->ControllerNameTable
);
706 FreePool (WinNtDevice
);
710 if (EFI_ERROR (Status
)) {
711 AllChildrenStopped
= FALSE
;
715 if (!AllChildrenStopped
) {
716 return EFI_DEVICE_ERROR
;
722 EFI_DEVICE_PATH_PROTOCOL
*
723 WinNtBusCreateDevicePath (
724 IN EFI_DEVICE_PATH_PROTOCOL
*RootDevicePath
,
726 IN UINT16 InstanceNumber
731 Create a device path node using Guid and InstanceNumber and append it to
732 the passed in RootDevicePath
735 RootDevicePath - Root of the device path to return.
737 Guid - GUID to use in vendor device path node.
739 InstanceNumber - Instance number to use in the vendor device path. This
740 argument is needed to make sure each device path is unique.
744 EFI_DEVICE_PATH_PROTOCOL
748 WIN_NT_VENDOR_DEVICE_PATH_NODE DevicePath
;
750 DevicePath
.VendorDevicePath
.Header
.Type
= HARDWARE_DEVICE_PATH
;
751 DevicePath
.VendorDevicePath
.Header
.SubType
= HW_VENDOR_DP
;
752 SetDevicePathNodeLength (&DevicePath
.VendorDevicePath
.Header
, sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE
));
755 // The GUID defines the Class
757 CopyMem (&DevicePath
.VendorDevicePath
.Guid
, Guid
, sizeof (EFI_GUID
));
760 // Add an instance number so we can make sure there are no Device Path
763 DevicePath
.Instance
= InstanceNumber
;
765 return AppendDevicePathNode (
767 (EFI_DEVICE_PATH_PROTOCOL
*) &DevicePath