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 BDS internal function define the default device path string, it can be
19 replaced by platform device path.
24 #ifdef TIANO_EXTENSION_FLAG
25 EFI_GUID UnknownDeviceGuid
= UNKNOWN_DEVICE_GUID
;
28 EFI_GUID mEfiUnixThunkProtocolGuid
= EFI_UNIX_THUNK_PROTOCOL_GUID
;
29 EFI_GUID mEfiUnixUgaGuid
= EFI_UNIX_UGA_GUID
;
30 EFI_GUID mEfiMsgPcAnsiGuid
= DEVICE_PATH_MESSAGING_PC_ANSI
;
31 EFI_GUID mEfiMsgVt100Guid
= DEVICE_PATH_MESSAGING_VT_100
;
32 EFI_GUID mEfiMsgVt100PlusGuid
= DEVICE_PATH_MESSAGING_VT_100_PLUS
;
33 EFI_GUID mEfiMsgVt100Utf8Guid
= DEVICE_PATH_MESSAGING_VT_UTF8
;
45 Adjusts the size of a previously allocated buffer.
49 OldPool - A pointer to the buffer whose size is being adjusted.
51 OldSize - The size of the current buffer.
53 NewSize - The size of the new buffer.
57 EFI_SUCEESS - The requested number of bytes were allocated.
59 EFI_OUT_OF_RESOURCES - The pool requested could not be allocated.
61 EFI_INVALID_PARAMETER - The buffer was invalid.
69 NewPool
= AllocateZeroPool (NewSize
);
74 CopyMem (NewPool
, OldPool
, OldSize
< NewSize
? OldSize
: NewSize
);
77 gBS
->FreePool (OldPool
);
85 IN OUT POOL_PRINT
*Str
,
93 Concatenates a formatted unicode string to allocated pool.
94 The caller must free the resulting buffer.
98 Str - Tracks the allocated pool, size in use, and
99 amount of pool allocated.
101 fmt - The format string
105 Allocated buffer with the formatted string printed in it.
106 The caller must free the allocated buffer. The buffer
107 allocation is not packed.
115 AppendStr
= AllocateZeroPool (0x1000);
116 if (AppendStr
== NULL
) {
120 VA_START (args
, fmt
);
121 UnicodeVSPrint (AppendStr
, 0x1000, fmt
, args
);
123 if (NULL
== Str
->str
) {
124 strsize
= StrSize (AppendStr
);
125 Str
->str
= AllocateZeroPool (strsize
);
126 ASSERT (Str
->str
!= NULL
);
128 strsize
= StrSize (AppendStr
) + StrSize (Str
->str
) - sizeof (UINT16
);
129 Str
->str
= ReallocatePool (
134 ASSERT (Str
->str
!= NULL
);
137 Str
->maxlen
= MAX_CHAR
* sizeof (UINT16
);
138 if (strsize
< Str
->maxlen
) {
139 StrCat (Str
->str
, AppendStr
);
140 Str
->len
= strsize
- sizeof (UINT16
);
143 gBS
->FreePool (AppendStr
);
147 EFI_DEVICE_PATH_PROTOCOL
*
148 BdsLibUnpackDevicePath (
149 IN EFI_DEVICE_PATH_PROTOCOL
*DevPath
155 Function unpacks a device path data structure so that all the nodes
156 of a device path are naturally aligned.
160 DevPath - A pointer to a device path data structure
164 If the memory for the device path is successfully allocated, then a
165 pointer to the new device path is returned. Otherwise, NULL is returned.
169 EFI_DEVICE_PATH_PROTOCOL
*Src
;
170 EFI_DEVICE_PATH_PROTOCOL
*Dest
;
171 EFI_DEVICE_PATH_PROTOCOL
*NewPath
;
175 // Walk device path and round sizes to valid boundries
180 Size
+= DevicePathNodeLength (Src
);
181 Size
+= ALIGN_SIZE (Size
);
183 if (IsDevicePathEnd (Src
)) {
187 Src
= NextDevicePathNode (Src
);
190 // Allocate space for the unpacked path
192 NewPath
= AllocateZeroPool (Size
);
195 ASSERT (((UINTN
) NewPath
) % MIN_ALIGNMENT_SIZE
== 0);
203 Size
= DevicePathNodeLength (Src
);
204 CopyMem (Dest
, Src
, Size
);
205 Size
+= ALIGN_SIZE (Size
);
206 SetDevicePathNodeLength (Dest
, Size
);
207 Dest
->Type
|= EFI_DP_TYPE_UNPACKED
;
208 Dest
= (EFI_DEVICE_PATH_PROTOCOL
*) (((UINT8
*) Dest
) + Size
);
210 if (IsDevicePathEnd (Src
)) {
214 Src
= NextDevicePathNode (Src
);
223 IN OUT POOL_PRINT
*Str
,
227 PCI_DEVICE_PATH
*Pci
;
230 CatPrint (Str
, L
"Pci(%x|%x)", Pci
->Device
, Pci
->Function
);
235 IN OUT POOL_PRINT
*Str
,
239 PCCARD_DEVICE_PATH
*Pccard
;
242 CatPrint (Str
, L
"Pcmcia(Function%x)", Pccard
->FunctionNumber
);
247 IN OUT POOL_PRINT
*Str
,
251 MEMMAP_DEVICE_PATH
*MemMap
;
256 L
"MemMap(%d:%.lx-%.lx)",
258 MemMap
->StartingAddress
,
259 MemMap
->EndingAddress
265 IN OUT POOL_PRINT
*Str
,
269 CONTROLLER_DEVICE_PATH
*Controller
;
271 Controller
= DevPath
;
272 CatPrint (Str
, L
"Ctrl(%d)", Controller
->ControllerNumber
);
277 IN OUT POOL_PRINT
*Str
,
284 Convert Vendor device path to device name
288 Str - The buffer store device name
289 DevPath - Pointer to vendor device path
293 When it return, the device name have been stored in *Str.
297 VENDOR_DEVICE_PATH
*Vendor
;
302 Temp
= (INT32
*) (&Vendor
->Guid
);
304 switch (DevicePathType (&Vendor
->Header
)) {
305 case HARDWARE_DEVICE_PATH
:
307 // If the device is an Unix device, we will give it a readable device name.
309 if (CompareGuid (&Vendor
->Guid
, &mEfiUnixThunkProtocolGuid
)) {
310 CatPrint (Str
, L
"%s", L
"UnixBus");
312 } else if (CompareGuid (&Vendor
->Guid
, &mEfiUnixUgaGuid
)) {
313 CatPrint (Str
, L
"%s", L
"UGA");
320 case MESSAGING_DEVICE_PATH
:
322 // If the device is an Unix device, we will give it a readable device name.
324 if (CompareGuid (&Vendor
->Guid
, &mEfiMsgPcAnsiGuid
)) {
325 CatPrint (Str
, L
"%s", L
"PC-ANSI");
327 } else if (CompareGuid (&Vendor
->Guid
, &mEfiMsgVt100Guid
)) {
328 CatPrint (Str
, L
"%s", L
"VT100");
330 } else if (CompareGuid (&Vendor
->Guid
, &mEfiMsgVt100PlusGuid
)) {
331 CatPrint (Str
, L
"%s", L
"VT100+");
333 } else if (CompareGuid (&Vendor
->Guid
, &mEfiMsgVt100Utf8Guid
)) {
334 CatPrint (Str
, L
"%s", L
"VT100-UTF8");
341 case MEDIA_DEVICE_PATH
:
350 CatPrint (Str
, L
"Ven%s(%g)", Type
, &Vendor
->Guid
);
355 IN OUT POOL_PRINT
*Str
,
359 ACPI_HID_DEVICE_PATH
*Acpi
;
362 if ((Acpi
->HID
& PNP_EISA_ID_MASK
) == PNP_EISA_ID_CONST
) {
363 CatPrint (Str
, L
"Acpi(PNP%04x,%x)", EISA_ID_TO_NUM (Acpi
->HID
), Acpi
->UID
);
365 CatPrint (Str
, L
"Acpi(%08x,%x)", Acpi
->HID
, Acpi
->UID
);
371 IN OUT POOL_PRINT
*Str
,
375 ATAPI_DEVICE_PATH
*Atapi
;
381 Atapi
->PrimarySecondary
? L
"Secondary" : L
"Primary",
382 Atapi
->SlaveMaster
? L
"Slave" : L
"Master"
388 IN OUT POOL_PRINT
*Str
,
392 SCSI_DEVICE_PATH
*Scsi
;
395 CatPrint (Str
, L
"Scsi(Pun%x,Lun%x)", Scsi
->Pun
, Scsi
->Lun
);
400 IN OUT POOL_PRINT
*Str
,
404 FIBRECHANNEL_DEVICE_PATH
*Fibre
;
407 CatPrint (Str
, L
"Fibre(Wwn%lx,Lun%x)", Fibre
->WWN
, Fibre
->Lun
);
412 IN OUT POOL_PRINT
*Str
,
416 F1394_DEVICE_PATH
*F1394
;
419 CatPrint (Str
, L
"1394(%g)", &F1394
->Guid
);
424 IN OUT POOL_PRINT
*Str
,
428 USB_DEVICE_PATH
*Usb
;
431 CatPrint (Str
, L
"Usb(%x, %x)", Usb
->ParentPortNumber
, Usb
->InterfaceNumber
);
436 IN OUT POOL_PRINT
*Str
,
440 USB_CLASS_DEVICE_PATH
*UsbClass
;
445 L
"Usb Class(%x, %x, %x, %x, %x)",
448 UsbClass
->DeviceClass
,
449 UsbClass
->DeviceSubClass
,
450 UsbClass
->DeviceProtocol
456 IN OUT POOL_PRINT
*Str
,
460 I2O_DEVICE_PATH
*I2O
;
463 CatPrint (Str
, L
"I2O(%x)", I2O
->Tid
);
468 IN OUT POOL_PRINT
*Str
,
472 MAC_ADDR_DEVICE_PATH
*MAC
;
478 HwAddressSize
= sizeof (EFI_MAC_ADDRESS
);
479 if (MAC
->IfType
== 0x01 || MAC
->IfType
== 0x00) {
483 CatPrint (Str
, L
"Mac(");
485 for (Index
= 0; Index
< HwAddressSize
; Index
++) {
486 CatPrint (Str
, L
"%02x", MAC
->MacAddress
.Addr
[Index
]);
489 CatPrint (Str
, L
")");
494 IN OUT POOL_PRINT
*Str
,
498 IPv4_DEVICE_PATH
*IP
;
503 L
"IPv4(%d.%d.%d.%d:%d)",
504 IP
->RemoteIpAddress
.Addr
[0],
505 IP
->RemoteIpAddress
.Addr
[1],
506 IP
->RemoteIpAddress
.Addr
[2],
507 IP
->RemoteIpAddress
.Addr
[3],
514 IN OUT POOL_PRINT
*Str
,
518 IPv6_DEVICE_PATH
*IP
;
521 CatPrint (Str
, L
"IP-v6(not-done)");
526 IN OUT POOL_PRINT
*Str
,
530 INFINIBAND_DEVICE_PATH
*InfiniBand
;
532 InfiniBand
= DevPath
;
533 CatPrint (Str
, L
"InfiniBand(not-done)");
538 IN OUT POOL_PRINT
*Str
,
542 UART_DEVICE_PATH
*Uart
;
546 switch (Uart
->Parity
) {
576 if (Uart
->BaudRate
== 0) {
577 CatPrint (Str
, L
"Uart(DEFAULT %c", Parity
);
579 CatPrint (Str
, L
"Uart(%d %c", Uart
->BaudRate
, Parity
);
582 if (Uart
->DataBits
== 0) {
583 CatPrint (Str
, L
"D");
585 CatPrint (Str
, L
"%d", Uart
->DataBits
);
588 switch (Uart
->StopBits
) {
590 CatPrint (Str
, L
"D)");
594 CatPrint (Str
, L
"1)");
598 CatPrint (Str
, L
"1.5)");
602 CatPrint (Str
, L
"2)");
606 CatPrint (Str
, L
"x)");
613 IN OUT POOL_PRINT
*Str
,
617 HARDDRIVE_DEVICE_PATH
*Hd
;
620 switch (Hd
->SignatureType
) {
621 case SIGNATURE_TYPE_MBR
:
624 L
"HD(Part%d,Sig%08x)",
626 *((UINT32
*) (&(Hd
->Signature
[0])))
630 case SIGNATURE_TYPE_GUID
:
635 (EFI_GUID
*) &(Hd
->Signature
[0])
642 L
"HD(Part%d,MBRType=%02x,SigType=%02x)",
653 IN OUT POOL_PRINT
*Str
,
657 CDROM_DEVICE_PATH
*Cd
;
660 CatPrint (Str
, L
"CDROM(Entry%x)", Cd
->BootEntry
);
665 IN OUT POOL_PRINT
*Str
,
669 FILEPATH_DEVICE_PATH
*Fp
;
672 CatPrint (Str
, L
"%s", Fp
->PathName
);
676 DevPathMediaProtocol (
677 IN OUT POOL_PRINT
*Str
,
681 MEDIA_PROTOCOL_DEVICE_PATH
*MediaProt
;
684 CatPrint (Str
, L
"%g", &MediaProt
->Protocol
);
689 IN OUT POOL_PRINT
*Str
,
693 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*FvFilePath
;
695 FvFilePath
= DevPath
;
696 CatPrint (Str
, L
"%g", &FvFilePath
->NameGuid
);
701 IN OUT POOL_PRINT
*Str
,
705 BBS_BBS_DEVICE_PATH
*Bbs
;
709 switch (Bbs
->DeviceType
) {
710 case BBS_TYPE_FLOPPY
:
714 case BBS_TYPE_HARDDRIVE
:
722 case BBS_TYPE_PCMCIA
:
730 case BBS_TYPE_EMBEDDED_NETWORK
:
739 // Since current Print function hasn't implemented %a (for ansi string)
740 // we will only print Unicode strings.
742 CatPrint (Str
, L
"Legacy-%s", Type
);
747 IN OUT POOL_PRINT
*Str
,
751 CatPrint (Str
, L
",");
756 IN OUT POOL_PRINT
*Str
,
760 CatPrint (Str
, L
"?");
763 DEVICE_PATH_STRING_TABLE DevPathTable
[] = {
765 HARDWARE_DEVICE_PATH
,
770 HARDWARE_DEVICE_PATH
,
775 HARDWARE_DEVICE_PATH
,
780 HARDWARE_DEVICE_PATH
,
785 HARDWARE_DEVICE_PATH
,
795 MESSAGING_DEVICE_PATH
,
800 MESSAGING_DEVICE_PATH
,
805 MESSAGING_DEVICE_PATH
,
810 MESSAGING_DEVICE_PATH
,
815 MESSAGING_DEVICE_PATH
,
820 MESSAGING_DEVICE_PATH
,
825 MESSAGING_DEVICE_PATH
,
830 MESSAGING_DEVICE_PATH
,
835 MESSAGING_DEVICE_PATH
,
840 MESSAGING_DEVICE_PATH
,
845 MESSAGING_DEVICE_PATH
,
850 MESSAGING_DEVICE_PATH
,
855 MESSAGING_DEVICE_PATH
,
885 #if (EFI_SPECIFICATION_VERSION < 0x00020000)
888 MEDIA_FV_FILEPATH_DP
,
899 END_DEVICE_PATH_TYPE
,
900 END_INSTANCE_DEVICE_PATH_SUBTYPE
,
912 IN EFI_DEVICE_PATH_PROTOCOL
*DevPath
916 Turns the Device Path into a printable string. Allcoates
917 the string from pool. The caller must SafeFreePool the returned
923 EFI_DEVICE_PATH_PROTOCOL
*DevPathNode
;
924 VOID (*DumpNode
) (POOL_PRINT
*, VOID
*);
929 ZeroMem (&Str
, sizeof (Str
));
931 if (DevPath
== NULL
) {
935 // Unpacked the device path
937 DevPath
= BdsLibUnpackDevicePath (DevPath
);
941 // Process each device path node
943 DevPathNode
= DevPath
;
944 while (!IsDevicePathEnd (DevPathNode
)) {
946 // Find the handler to dump this device path node
949 for (Index
= 0; DevPathTable
[Index
].Function
; Index
+= 1) {
951 if (DevicePathType (DevPathNode
) == DevPathTable
[Index
].Type
&&
952 DevicePathSubType (DevPathNode
) == DevPathTable
[Index
].SubType
954 DumpNode
= DevPathTable
[Index
].Function
;
959 // If not found, use a generic function
962 DumpNode
= DevPathNodeUnknown
;
965 // Put a path seperator in if needed
967 if (Str
.len
&& DumpNode
!= DevPathEndInstance
) {
968 CatPrint (&Str
, L
"/");
971 // Print this node of the device path
973 DumpNode (&Str
, DevPathNode
);
976 // Next device path node
978 DevPathNode
= NextDevicePathNode (DevPathNode
);
981 // Shrink pool used for string allocation
983 gBS
->FreePool (DevPath
);
986 NewSize
= (Str
.len
+ 1) * sizeof (CHAR16
);
987 Str
.str
= ReallocatePool (Str
.str
, NewSize
, NewSize
);
988 ASSERT (Str
.str
!= NULL
);
989 Str
.str
[Str
.len
] = 0;
993 EFI_DEVICE_PATH_PROTOCOL
*
994 LibDuplicateDevicePathInstance (
995 IN EFI_DEVICE_PATH_PROTOCOL
*DevPath
1001 Function creates a device path data structure that identically matches the
1002 device path passed in.
1006 DevPath - A pointer to a device path data structure.
1010 The new copy of DevPath is created to identically match the input.
1011 Otherwise, NULL is returned.
1015 EFI_DEVICE_PATH_PROTOCOL
*NewDevPath
;
1016 EFI_DEVICE_PATH_PROTOCOL
*DevicePathInst
;
1017 EFI_DEVICE_PATH_PROTOCOL
*Temp
;
1021 // get the size of an instance from the input
1024 DevicePathInst
= GetNextDevicePathInstance (&Temp
, &Size
);
1031 NewDevPath
= AllocateZeroPool (Size
);
1032 ASSERT (NewDevPath
!= NULL
);
1036 CopyMem (NewDevPath
, DevicePathInst
, Size
);