]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/DevicePathDxe/DevicePathToText.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add some ASSERT()s.
[mirror_edk2.git] / MdeModulePkg / Universal / DevicePathDxe / DevicePathToText.c
1 /** @file
2 DevicePathToText protocol as defined in the UEFI 2.0 specification.
3
4 Copyright (c) 2006 - 2008, Intel Corporation. <BR>
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "DevicePath.h"
16
17 /**
18 Concatenates a formatted unicode string to allocated pool. The caller must
19 free the resulting buffer.
20
21 @param Str Tracks the allocated pool, size in use, and
22 amount of pool allocated.
23 @param Fmt The format string
24 @param ... Variable arguments based on the format string.
25
26 @return Allocated buffer with the formatted string printed in it.
27 The caller must free the allocated buffer. The buffer
28 allocation is not packed.
29
30 **/
31 CHAR16 *
32 CatPrint (
33 IN OUT POOL_PRINT *Str,
34 IN CHAR16 *Fmt,
35 ...
36 )
37 {
38 UINT16 *AppendStr;
39 VA_LIST Args;
40 UINTN Size;
41
42 AppendStr = AllocateZeroPool (0x1000);
43 if (AppendStr == NULL) {
44 return Str->Str;
45 }
46
47 VA_START (Args, Fmt);
48 UnicodeVSPrint (AppendStr, 0x1000, Fmt, Args);
49 VA_END (Args);
50 if (NULL == Str->Str) {
51 Size = StrSize (AppendStr);
52 Str->Str = AllocateZeroPool (Size);
53 ASSERT (Str->Str != NULL);
54 } else {
55 Size = StrSize (AppendStr) - sizeof (UINT16);
56 Size = Size + StrSize (Str->Str);
57 Str->Str = ReallocatePool (
58 StrSize (Str->Str),
59 Size,
60 Str->Str
61 );
62 ASSERT (Str->Str != NULL);
63 }
64
65 Str->MaxLen = MAX_CHAR * sizeof (UINT16);
66 if (Size < Str->MaxLen) {
67 StrCat (Str->Str, AppendStr);
68 Str->Len = Size - sizeof (UINT16);
69 }
70
71 FreePool (AppendStr);
72 return Str->Str;
73 }
74
75 /**
76 Converts a PCI device path structure to its string representative.
77
78 @param Str The string representative of input device.
79 @param DevPath The input device path structure.
80 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
81 of the display node is used, where applicable. If DisplayOnly
82 is FALSE, then the longer text representation of the display node
83 is used.
84 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
85 representation for a device node can be used, where applicable.
86
87 **/
88 VOID
89 DevPathToTextPci (
90 IN OUT POOL_PRINT *Str,
91 IN VOID *DevPath,
92 IN BOOLEAN DisplayOnly,
93 IN BOOLEAN AllowShortcuts
94 )
95 {
96 PCI_DEVICE_PATH *Pci;
97
98 Pci = DevPath;
99 CatPrint (Str, L"Pci(0x%x,0x%x)", Pci->Device, Pci->Function);
100 }
101
102 /**
103 Converts a PC Card device path structure to its string representative.
104
105 @param Str The string representative of input device.
106 @param DevPath The input device path structure.
107 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
108 of the display node is used, where applicable. If DisplayOnly
109 is FALSE, then the longer text representation of the display node
110 is used.
111 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
112 representation for a device node can be used, where applicable.
113
114 **/
115 VOID
116 DevPathToTextPccard (
117 IN OUT POOL_PRINT *Str,
118 IN VOID *DevPath,
119 IN BOOLEAN DisplayOnly,
120 IN BOOLEAN AllowShortcuts
121 )
122 {
123 PCCARD_DEVICE_PATH *Pccard;
124
125 Pccard = DevPath;
126 CatPrint (Str, L"PcCard(0x%x)", Pccard->FunctionNumber);
127 }
128
129 /**
130 Converts a Memory Map device path structure to its string representative.
131
132 @param Str The string representative of input device.
133 @param DevPath The input device path structure.
134 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
135 of the display node is used, where applicable. If DisplayOnly
136 is FALSE, then the longer text representation of the display node
137 is used.
138 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
139 representation for a device node can be used, where applicable.
140
141 **/
142 VOID
143 DevPathToTextMemMap (
144 IN OUT POOL_PRINT *Str,
145 IN VOID *DevPath,
146 IN BOOLEAN DisplayOnly,
147 IN BOOLEAN AllowShortcuts
148 )
149 {
150 MEMMAP_DEVICE_PATH *MemMap;
151
152 MemMap = DevPath;
153 CatPrint (
154 Str,
155 L"MemoryMapped(0x%x,0x%lx,0x%lx)",
156 MemMap->MemoryType,
157 MemMap->StartingAddress,
158 MemMap->EndingAddress
159 );
160 }
161
162 /**
163 Converts a Vendor device path structure to its string representative.
164
165 @param Str The string representative of input device.
166 @param DevPath The input device path structure.
167 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
168 of the display node is used, where applicable. If DisplayOnly
169 is FALSE, then the longer text representation of the display node
170 is used.
171 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
172 representation for a device node can be used, where applicable.
173
174 **/
175 VOID
176 DevPathToTextVendor (
177 IN OUT POOL_PRINT *Str,
178 IN VOID *DevPath,
179 IN BOOLEAN DisplayOnly,
180 IN BOOLEAN AllowShortcuts
181 )
182 {
183 VENDOR_DEVICE_PATH *Vendor;
184 CHAR16 *Type;
185 UINTN Index;
186 UINTN DataLength;
187 UINT32 FlowControlMap;
188 UINT16 Info;
189
190 Vendor = (VENDOR_DEVICE_PATH *) DevPath;
191 switch (DevicePathType (&Vendor->Header)) {
192 case HARDWARE_DEVICE_PATH:
193 Type = L"Hw";
194 break;
195
196 case MESSAGING_DEVICE_PATH:
197 Type = L"Msg";
198 if (AllowShortcuts) {
199 if (CompareGuid (&Vendor->Guid, &gEfiPcAnsiGuid)) {
200 CatPrint (Str, L"VenPcAnsi()");
201 return ;
202 } else if (CompareGuid (&Vendor->Guid, &gEfiVT100Guid)) {
203 CatPrint (Str, L"VenVt100()");
204 return ;
205 } else if (CompareGuid (&Vendor->Guid, &gEfiVT100PlusGuid)) {
206 CatPrint (Str, L"VenVt100Plus()");
207 return ;
208 } else if (CompareGuid (&Vendor->Guid, &gEfiVTUTF8Guid)) {
209 CatPrint (Str, L"VenUft8()");
210 return ;
211 } else if (CompareGuid (&Vendor->Guid, &gEfiUartDevicePathGuid)) {
212 FlowControlMap = (((UART_FLOW_CONTROL_DEVICE_PATH *) Vendor)->FlowControlMap);
213 switch (FlowControlMap & 0x00000003) {
214 case 0:
215 CatPrint (Str, L"UartFlowCtrl(%s)", L"None");
216 break;
217
218 case 1:
219 CatPrint (Str, L"UartFlowCtrl(%s)", L"Hardware");
220 break;
221
222 case 2:
223 CatPrint (Str, L"UartFlowCtrl(%s)", L"XonXoff");
224 break;
225
226 default:
227 break;
228 }
229
230 return ;
231 } else if (CompareGuid (&Vendor->Guid, &gEfiSasDevicePathGuid)) {
232 CatPrint (
233 Str,
234 L"SAS(0x%lx,0x%lx,0x%x,",
235 ((SAS_DEVICE_PATH *) Vendor)->SasAddress,
236 ((SAS_DEVICE_PATH *) Vendor)->Lun,
237 ((SAS_DEVICE_PATH *) Vendor)->RelativeTargetPort
238 );
239 Info = (((SAS_DEVICE_PATH *) Vendor)->DeviceTopology);
240 if ((Info & 0x0f) == 0) {
241 CatPrint (Str, L"NoTopology,0,0,0,");
242 } else if (((Info & 0x0f) == 1) || ((Info & 0x0f) == 2)) {
243 CatPrint (
244 Str,
245 L"%s,%s,%s,",
246 ((Info & (0x1 << 4)) != 0) ? L"SATA" : L"SAS",
247 ((Info & (0x1 << 5)) != 0) ? L"External" : L"Internal",
248 ((Info & (0x1 << 6)) != 0) ? L"Expanded" : L"Direct"
249 );
250 if ((Info & 0x0f) == 1) {
251 CatPrint (Str, L"0,");
252 } else {
253 CatPrint (Str, L"0x%x,", (Info >> 8) & 0xff);
254 }
255 } else {
256 CatPrint (Str, L"0,0,0,0,");
257 }
258
259 CatPrint (Str, L"0x%x)", ((SAS_DEVICE_PATH *) Vendor)->Reserved);
260 return ;
261 } else if (CompareGuid (&Vendor->Guid, &gEfiDebugPortProtocolGuid)) {
262 CatPrint (Str, L"DebugPort()");
263 return ;
264 }
265 }
266 break;
267
268 case MEDIA_DEVICE_PATH:
269 Type = L"Media";
270 break;
271
272 default:
273 Type = L"?";
274 break;
275 }
276
277 DataLength = DevicePathNodeLength (&Vendor->Header) - sizeof (VENDOR_DEVICE_PATH);
278 CatPrint (Str, L"Ven%s(%g", Type, &Vendor->Guid);
279 if (DataLength != 0) {
280 CatPrint (Str, L",");
281 for (Index = 0; Index < DataLength; Index++) {
282 CatPrint (Str, L"%02x", ((VENDOR_DEVICE_PATH_WITH_DATA *) Vendor)->VendorDefinedData[Index]);
283 }
284 }
285
286 CatPrint (Str, L")");
287 }
288
289 /**
290 Converts a Controller device path structure to its string representative.
291
292 @param Str The string representative of input device.
293 @param DevPath The input device path structure.
294 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
295 of the display node is used, where applicable. If DisplayOnly
296 is FALSE, then the longer text representation of the display node
297 is used.
298 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
299 representation for a device node can be used, where applicable.
300
301 **/
302 VOID
303 DevPathToTextController (
304 IN OUT POOL_PRINT *Str,
305 IN VOID *DevPath,
306 IN BOOLEAN DisplayOnly,
307 IN BOOLEAN AllowShortcuts
308 )
309 {
310 CONTROLLER_DEVICE_PATH *Controller;
311
312 Controller = DevPath;
313 CatPrint (
314 Str,
315 L"Ctrl(0x%x)",
316 Controller->ControllerNumber
317 );
318 }
319
320 /**
321 Converts a ACPI device path structure to its string representative.
322
323 @param Str The string representative of input device.
324 @param DevPath The input device path structure.
325 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
326 of the display node is used, where applicable. If DisplayOnly
327 is FALSE, then the longer text representation of the display node
328 is used.
329 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
330 representation for a device node can be used, where applicable.
331
332 **/
333 VOID
334 DevPathToTextAcpi (
335 IN OUT POOL_PRINT *Str,
336 IN VOID *DevPath,
337 IN BOOLEAN DisplayOnly,
338 IN BOOLEAN AllowShortcuts
339 )
340 {
341 ACPI_HID_DEVICE_PATH *Acpi;
342
343 Acpi = DevPath;
344 if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
345 switch (EISA_ID_TO_NUM (Acpi->HID)) {
346 case 0x0a03:
347 CatPrint (Str, L"PciRoot(0x%x)", Acpi->UID);
348 break;
349
350 case 0x0604:
351 CatPrint (Str, L"Floppy(0x%x)", Acpi->UID);
352 break;
353
354 case 0x0301:
355 CatPrint (Str, L"Keyboard(0x%x)", Acpi->UID);
356 break;
357
358 case 0x0501:
359 CatPrint (Str, L"Serial(0x%x)", Acpi->UID);
360 break;
361
362 case 0x0401:
363 CatPrint (Str, L"ParallelPort(0x%x)", Acpi->UID);
364 break;
365
366 default:
367 CatPrint (Str, L"Acpi(PNP%04x,0x%x)", EISA_ID_TO_NUM (Acpi->HID), Acpi->UID);
368 break;
369 }
370 } else {
371 CatPrint (Str, L"Acpi(0x%08x,0x%x)", Acpi->HID, Acpi->UID);
372 }
373 }
374
375 /**
376 Converts EISA identification to string.
377
378 @param EisaId The input EISA identification.
379 @param Text A pointer to the output string.
380
381 **/
382 VOID
383 EisaIdToText (
384 IN UINT32 EisaId,
385 IN OUT CHAR16 *Text
386 )
387 {
388 CHAR16 PnpIdStr[17];
389
390 //
391 //UnicodeSPrint ("%X", 0x0a03) => "0000000000000A03"
392 //
393 UnicodeSPrint (PnpIdStr, 17 * 2, L"%16X", EisaId >> 16);
394
395 UnicodeSPrint (
396 Text,
397 sizeof (CHAR16) + sizeof (CHAR16) + sizeof (CHAR16) + sizeof (PnpIdStr),
398 L"%c%c%c%s",
399 '@' + ((EisaId >> 10) & 0x1f),
400 '@' + ((EisaId >> 5) & 0x1f),
401 '@' + ((EisaId >> 0) & 0x1f),
402 PnpIdStr + (16 - 4)
403 );
404 }
405
406 /**
407 Converts a ACPI extended HID device path structure to its string representative.
408
409 @param Str The string representative of input device.
410 @param DevPath The input device path structure.
411 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
412 of the display node is used, where applicable. If DisplayOnly
413 is FALSE, then the longer text representation of the display node
414 is used.
415 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
416 representation for a device node can be used, where applicable.
417
418 **/
419 VOID
420 DevPathToTextAcpiEx (
421 IN OUT POOL_PRINT *Str,
422 IN VOID *DevPath,
423 IN BOOLEAN DisplayOnly,
424 IN BOOLEAN AllowShortcuts
425 )
426 {
427 ACPI_EXTENDED_HID_DEVICE_PATH *AcpiEx;
428 CHAR8 *HIDStr;
429 CHAR8 *UIDStr;
430 CHAR8 *CIDStr;
431 CHAR16 HIDText[11];
432 CHAR16 CIDText[11];
433
434 AcpiEx = DevPath;
435 HIDStr = (CHAR8 *) (((UINT8 *) AcpiEx) + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
436 UIDStr = HIDStr + AsciiStrLen (HIDStr) + 1;
437 CIDStr = UIDStr + AsciiStrLen (UIDStr) + 1;
438
439 EisaIdToText (AcpiEx->HID, HIDText);
440 EisaIdToText (AcpiEx->CID, CIDText);
441
442 if ((*HIDStr == '\0') && (*CIDStr == '\0') && (AcpiEx->UID == 0)) {
443 //
444 // use AcpiExp()
445 //
446 CatPrint (
447 Str,
448 L"AcpiExp(%s,%s,%a)",
449 HIDText,
450 CIDText,
451 UIDStr
452 );
453 } else {
454 if (AllowShortcuts) {
455 //
456 // display only
457 //
458 if (AcpiEx->HID == 0) {
459 CatPrint (Str, L"AcpiEx(%a,", HIDStr);
460 } else {
461 CatPrint (Str, L"AcpiEx(%s,", HIDText);
462 }
463
464 if (AcpiEx->UID == 0) {
465 CatPrint (Str, L"%a,", UIDStr);
466 } else {
467 CatPrint (Str, L"0x%x,", AcpiEx->UID);
468 }
469
470 if (AcpiEx->CID == 0) {
471 CatPrint (Str, L"%a)", CIDStr);
472 } else {
473 CatPrint (Str, L"%s)", CIDText);
474 }
475 } else {
476 CatPrint (
477 Str,
478 L"AcpiEx(%s,%s,0x%x,%a,%a,%a)",
479 HIDText,
480 CIDText,
481 AcpiEx->UID,
482 HIDStr,
483 CIDStr,
484 UIDStr
485 );
486 }
487 }
488 }
489
490 /**
491 Converts a ACPI address device path structure to its string representative.
492
493 @param Str The string representative of input device.
494 @param DevPath The input device path structure.
495 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
496 of the display node is used, where applicable. If DisplayOnly
497 is FALSE, then the longer text representation of the display node
498 is used.
499 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
500 representation for a device node can be used, where applicable.
501
502 **/
503 VOID
504 DevPathToTextAcpiAdr (
505 IN OUT POOL_PRINT *Str,
506 IN VOID *DevPath,
507 IN BOOLEAN DisplayOnly,
508 IN BOOLEAN AllowShortcuts
509 )
510 {
511 ACPI_ADR_DEVICE_PATH *AcpiAdr;
512 UINT16 Index;
513 UINT16 Length;
514 UINT16 AdditionalAdrCount;
515
516 AcpiAdr = DevPath;
517 Length = (UINT16) DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) AcpiAdr);
518 AdditionalAdrCount = (UINT16) ((Length - 8) / 4);
519
520 CatPrint (Str, L"AcpiAdr(0x%x", AcpiAdr->ADR);
521 for (Index = 0; Index < AdditionalAdrCount; Index++) {
522 CatPrint (Str, L",0x%x", *(UINT32 *) ((UINT8 *) AcpiAdr + 8 + Index * 4));
523 }
524 CatPrint (Str, L")");
525 }
526
527 /**
528 Converts a ATAPI device path structure to its string representative.
529
530 @param Str The string representative of input device.
531 @param DevPath The input device path structure.
532 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
533 of the display node is used, where applicable. If DisplayOnly
534 is FALSE, then the longer text representation of the display node
535 is used.
536 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
537 representation for a device node can be used, where applicable.
538
539 **/
540 VOID
541 DevPathToTextAtapi (
542 IN OUT POOL_PRINT *Str,
543 IN VOID *DevPath,
544 IN BOOLEAN DisplayOnly,
545 IN BOOLEAN AllowShortcuts
546 )
547 {
548 ATAPI_DEVICE_PATH *Atapi;
549
550 Atapi = DevPath;
551
552 if (DisplayOnly) {
553 CatPrint (Str, L"Ata(0x%x)", Atapi->Lun);
554 } else {
555 CatPrint (
556 Str,
557 L"Ata(%s,%s,0x%x)",
558 Atapi->PrimarySecondary ? L"Secondary" : L"Primary",
559 Atapi->SlaveMaster ? L"Slave" : L"Master",
560 Atapi->Lun
561 );
562 }
563 }
564
565 /**
566 Converts a SCSI device path structure to its string representative.
567
568 @param Str The string representative of input device.
569 @param DevPath The input device path structure.
570 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
571 of the display node is used, where applicable. If DisplayOnly
572 is FALSE, then the longer text representation of the display node
573 is used.
574 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
575 representation for a device node can be used, where applicable.
576
577 **/
578 VOID
579 DevPathToTextScsi (
580 IN OUT POOL_PRINT *Str,
581 IN VOID *DevPath,
582 IN BOOLEAN DisplayOnly,
583 IN BOOLEAN AllowShortcuts
584 )
585 {
586 SCSI_DEVICE_PATH *Scsi;
587
588 Scsi = DevPath;
589 CatPrint (Str, L"Scsi(0x%x,0x%x)", Scsi->Pun, Scsi->Lun);
590 }
591
592 /**
593 Converts a Fibre device path structure to its string representative.
594
595 @param Str The string representative of input device.
596 @param DevPath The input device path structure.
597 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
598 of the display node is used, where applicable. If DisplayOnly
599 is FALSE, then the longer text representation of the display node
600 is used.
601 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
602 representation for a device node can be used, where applicable.
603
604 **/
605 VOID
606 DevPathToTextFibre (
607 IN OUT POOL_PRINT *Str,
608 IN VOID *DevPath,
609 IN BOOLEAN DisplayOnly,
610 IN BOOLEAN AllowShortcuts
611 )
612 {
613 FIBRECHANNEL_DEVICE_PATH *Fibre;
614
615 Fibre = DevPath;
616 CatPrint (Str, L"Fibre(0x%lx,0x%lx)", Fibre->WWN, Fibre->Lun);
617 }
618
619 /**
620 Converts a 1394 device path structure to its string representative.
621
622 @param Str The string representative of input device.
623 @param DevPath The input device path structure.
624 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
625 of the display node is used, where applicable. If DisplayOnly
626 is FALSE, then the longer text representation of the display node
627 is used.
628 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
629 representation for a device node can be used, where applicable.
630
631 **/
632 VOID
633 DevPathToText1394 (
634 IN OUT POOL_PRINT *Str,
635 IN VOID *DevPath,
636 IN BOOLEAN DisplayOnly,
637 IN BOOLEAN AllowShortcuts
638 )
639 {
640 F1394_DEVICE_PATH *F1394DevPath;
641
642 F1394DevPath = DevPath;
643 //
644 // Guid has format of IEEE-EUI64
645 //
646 CatPrint (Str, L"I1394(%016lx)", F1394DevPath->Guid);
647 }
648
649 /**
650 Converts a USB device path structure to its string representative.
651
652 @param Str The string representative of input device.
653 @param DevPath The input device path structure.
654 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
655 of the display node is used, where applicable. If DisplayOnly
656 is FALSE, then the longer text representation of the display node
657 is used.
658 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
659 representation for a device node can be used, where applicable.
660
661 **/
662 VOID
663 DevPathToTextUsb (
664 IN OUT POOL_PRINT *Str,
665 IN VOID *DevPath,
666 IN BOOLEAN DisplayOnly,
667 IN BOOLEAN AllowShortcuts
668 )
669 {
670 USB_DEVICE_PATH *Usb;
671
672 Usb = DevPath;
673 CatPrint (Str, L"USB(0x%x,0x%x)", Usb->ParentPortNumber, Usb->InterfaceNumber);
674 }
675
676 /**
677 Converts a USB WWID device path structure to its string representative.
678
679 @param Str The string representative of input device.
680 @param DevPath The input device path structure.
681 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
682 of the display node is used, where applicable. If DisplayOnly
683 is FALSE, then the longer text representation of the display node
684 is used.
685 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
686 representation for a device node can be used, where applicable.
687
688 **/
689 VOID
690 DevPathToTextUsbWWID (
691 IN OUT POOL_PRINT *Str,
692 IN VOID *DevPath,
693 IN BOOLEAN DisplayOnly,
694 IN BOOLEAN AllowShortcuts
695 )
696 {
697 USB_WWID_DEVICE_PATH *UsbWWId;
698 CHAR16 *SerialNumberStr;
699 CHAR16 *NewStr;
700 UINT16 Length;
701
702 UsbWWId = DevPath;
703
704 SerialNumberStr = (CHAR16 *) ((UINT8 *) UsbWWId + sizeof (USB_WWID_DEVICE_PATH));
705 Length = (UINT16) ((DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) UsbWWId) - sizeof (USB_WWID_DEVICE_PATH)) / sizeof (CHAR16));
706 if (SerialNumberStr [Length - 1] != 0) {
707 //
708 // In case no NULL terminator in SerialNumber, create a new one with NULL terminator
709 //
710 NewStr = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), SerialNumberStr);
711 ASSERT (NewStr != NULL);
712 NewStr [Length] = 0;
713 SerialNumberStr = NewStr;
714 }
715
716 CatPrint (
717 Str,
718 L"UsbWwid(0x%x,0x%x,0x%x,\"%s\")",
719 UsbWWId->VendorId,
720 UsbWWId->ProductId,
721 UsbWWId->InterfaceNumber,
722 SerialNumberStr
723 );
724 }
725
726 /**
727 Converts a Logic Unit device path structure to its string representative.
728
729 @param Str The string representative of input device.
730 @param DevPath The input device path structure.
731 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
732 of the display node is used, where applicable. If DisplayOnly
733 is FALSE, then the longer text representation of the display node
734 is used.
735 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
736 representation for a device node can be used, where applicable.
737
738 **/
739 VOID
740 DevPathToTextLogicalUnit (
741 IN OUT POOL_PRINT *Str,
742 IN VOID *DevPath,
743 IN BOOLEAN DisplayOnly,
744 IN BOOLEAN AllowShortcuts
745 )
746 {
747 DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;
748
749 LogicalUnit = DevPath;
750 CatPrint (Str, L"Unit(0x%x)", LogicalUnit->Lun);
751 }
752
753 /**
754 Converts a USB class device path structure to its string representative.
755
756 @param Str The string representative of input device.
757 @param DevPath The input device path structure.
758 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
759 of the display node is used, where applicable. If DisplayOnly
760 is FALSE, then the longer text representation of the display node
761 is used.
762 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
763 representation for a device node can be used, where applicable.
764
765 **/
766 VOID
767 DevPathToTextUsbClass (
768 IN OUT POOL_PRINT *Str,
769 IN VOID *DevPath,
770 IN BOOLEAN DisplayOnly,
771 IN BOOLEAN AllowShortcuts
772 )
773 {
774 USB_CLASS_DEVICE_PATH *UsbClass;
775 BOOLEAN IsKnownSubClass;
776
777
778 UsbClass = DevPath;
779
780 IsKnownSubClass = TRUE;
781 switch (UsbClass->DeviceClass) {
782 case USB_CLASS_AUDIO:
783 CatPrint (Str, L"UsbAudio");
784 break;
785
786 case USB_CLASS_CDCCONTROL:
787 CatPrint (Str, L"UsbCDCControl");
788 break;
789
790 case USB_CLASS_HID:
791 CatPrint (Str, L"UsbHID");
792 break;
793
794 case USB_CLASS_IMAGE:
795 CatPrint (Str, L"UsbImage");
796 break;
797
798 case USB_CLASS_PRINTER:
799 CatPrint (Str, L"UsbPrinter");
800 break;
801
802 case USB_CLASS_MASS_STORAGE:
803 CatPrint (Str, L"UsbMassStorage");
804 break;
805
806 case USB_CLASS_HUB:
807 CatPrint (Str, L"UsbHub");
808 break;
809
810 case USB_CLASS_CDCDATA:
811 CatPrint (Str, L"UsbCDCData");
812 break;
813
814 case USB_CLASS_SMART_CARD:
815 CatPrint (Str, L"UsbSmartCard");
816 break;
817
818 case USB_CLASS_VIDEO:
819 CatPrint (Str, L"UsbVideo");
820 break;
821
822 case USB_CLASS_DIAGNOSTIC:
823 CatPrint (Str, L"UsbDiagnostic");
824 break;
825
826 case USB_CLASS_WIRELESS:
827 CatPrint (Str, L"UsbWireless");
828 break;
829
830 default:
831 IsKnownSubClass = FALSE;
832 break;
833 }
834
835 if (IsKnownSubClass) {
836 CatPrint (
837 Str,
838 L"(0x%x,0x%x,0x%x,0x%x)",
839 UsbClass->VendorId,
840 UsbClass->ProductId,
841 UsbClass->DeviceSubClass,
842 UsbClass->DeviceProtocol
843 );
844 return;
845 }
846
847 if (UsbClass->DeviceClass == USB_CLASS_RESERVE) {
848 if (UsbClass->DeviceSubClass == USB_SUBCLASS_FW_UPDATE) {
849 CatPrint (
850 Str,
851 L"UsbDeviceFirmwareUpdate(0x%x,0x%x,0x%x)",
852 UsbClass->VendorId,
853 UsbClass->ProductId,
854 UsbClass->DeviceProtocol
855 );
856 return;
857 } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_IRDA_BRIDGE) {
858 CatPrint (
859 Str,
860 L"UsbIrdaBridge(0x%x,0x%x,0x%x)",
861 UsbClass->VendorId,
862 UsbClass->ProductId,
863 UsbClass->DeviceProtocol
864 );
865 return;
866 } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_TEST) {
867 CatPrint (
868 Str,
869 L"UsbTestAndMeasurement(0x%x,0x%x,0x%x)",
870 UsbClass->VendorId,
871 UsbClass->ProductId,
872 UsbClass->DeviceProtocol
873 );
874 return;
875 }
876 }
877
878 CatPrint (
879 Str,
880 L"UsbClass(0x%x,0x%x,0x%x,0x%x,0x%x)",
881 UsbClass->VendorId,
882 UsbClass->ProductId,
883 UsbClass->DeviceClass,
884 UsbClass->DeviceSubClass,
885 UsbClass->DeviceProtocol
886 );
887 }
888
889 /**
890 Converts a SATA device path structure to its string representative.
891
892 @param Str The string representative of input device.
893 @param DevPath The input device path structure.
894 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
895 of the display node is used, where applicable. If DisplayOnly
896 is FALSE, then the longer text representation of the display node
897 is used.
898 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
899 representation for a device node can be used, where applicable.
900
901 **/
902 VOID
903 DevPathToTextSata (
904 IN OUT POOL_PRINT *Str,
905 IN VOID *DevPath,
906 IN BOOLEAN DisplayOnly,
907 IN BOOLEAN AllowShortcuts
908 )
909 {
910 SATA_DEVICE_PATH *Sata;
911
912 Sata = DevPath;
913 CatPrint (
914 Str,
915 L"Sata(0x%x,0x%x,0x%x)",
916 (UINTN) Sata->HBAPortNumber,
917 (UINTN) Sata->PortMultiplierPortNumber,
918 (UINTN) Sata->Lun
919 );
920 }
921
922 /**
923 Converts a I20 device path structure to its string representative.
924
925 @param Str The string representative of input device.
926 @param DevPath The input device path structure.
927 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
928 of the display node is used, where applicable. If DisplayOnly
929 is FALSE, then the longer text representation of the display node
930 is used.
931 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
932 representation for a device node can be used, where applicable.
933
934 **/
935 VOID
936 DevPathToTextI2O (
937 IN OUT POOL_PRINT *Str,
938 IN VOID *DevPath,
939 IN BOOLEAN DisplayOnly,
940 IN BOOLEAN AllowShortcuts
941 )
942 {
943 I2O_DEVICE_PATH *I2ODevPath;
944
945 I2ODevPath = DevPath;
946 CatPrint (Str, L"I2O(0x%x)", I2ODevPath->Tid);
947 }
948
949 /**
950 Converts a MAC address device path structure to its string representative.
951
952 @param Str The string representative of input device.
953 @param DevPath The input device path structure.
954 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
955 of the display node is used, where applicable. If DisplayOnly
956 is FALSE, then the longer text representation of the display node
957 is used.
958 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
959 representation for a device node can be used, where applicable.
960
961 **/
962 VOID
963 DevPathToTextMacAddr (
964 IN OUT POOL_PRINT *Str,
965 IN VOID *DevPath,
966 IN BOOLEAN DisplayOnly,
967 IN BOOLEAN AllowShortcuts
968 )
969 {
970 MAC_ADDR_DEVICE_PATH *MacDevPath;
971 UINTN HwAddressSize;
972 UINTN Index;
973
974 MacDevPath = DevPath;
975
976 HwAddressSize = sizeof (EFI_MAC_ADDRESS);
977 if (MacDevPath->IfType == 0x01 || MacDevPath->IfType == 0x00) {
978 HwAddressSize = 6;
979 }
980
981 CatPrint (Str, L"MAC(");
982
983 for (Index = 0; Index < HwAddressSize; Index++) {
984 CatPrint (Str, L"%02x", MacDevPath->MacAddress.Addr[Index]);
985 }
986
987 CatPrint (Str, L",0x%x)", MacDevPath->IfType);
988 }
989
990 /**
991 Converts a IPv4 device path structure to its string representative.
992
993 @param Str The string representative of input device.
994 @param DevPath The input device path structure.
995 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
996 of the display node is used, where applicable. If DisplayOnly
997 is FALSE, then the longer text representation of the display node
998 is used.
999 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1000 representation for a device node can be used, where applicable.
1001
1002 **/
1003 VOID
1004 DevPathToTextIPv4 (
1005 IN OUT POOL_PRINT *Str,
1006 IN VOID *DevPath,
1007 IN BOOLEAN DisplayOnly,
1008 IN BOOLEAN AllowShortcuts
1009 )
1010 {
1011 IPv4_DEVICE_PATH *IPDevPath;
1012
1013 IPDevPath = DevPath;
1014 if (DisplayOnly) {
1015 CatPrint (
1016 Str,
1017 L"IPv4(%d.%d.%d.%d)",
1018 IPDevPath->RemoteIpAddress.Addr[0],
1019 IPDevPath->RemoteIpAddress.Addr[1],
1020 IPDevPath->RemoteIpAddress.Addr[2],
1021 IPDevPath->RemoteIpAddress.Addr[3]
1022 );
1023 return ;
1024 }
1025
1026 CatPrint (
1027 Str,
1028 L"IPv4(%d.%d.%d.%d,%s,%s,%d.%d.%d.%d)",
1029 IPDevPath->RemoteIpAddress.Addr[0],
1030 IPDevPath->RemoteIpAddress.Addr[1],
1031 IPDevPath->RemoteIpAddress.Addr[2],
1032 IPDevPath->RemoteIpAddress.Addr[3],
1033 IPDevPath->Protocol ? L"TCP" : L"UDP",
1034 (IPDevPath->StaticIpAddress == TRUE) ? L"Static" : L"DHCP",
1035 IPDevPath->LocalIpAddress.Addr[0],
1036 IPDevPath->LocalIpAddress.Addr[1],
1037 IPDevPath->LocalIpAddress.Addr[2],
1038 IPDevPath->LocalIpAddress.Addr[3]
1039 );
1040 }
1041
1042 /**
1043 Converts a IPv6 device path structure to its string representative.
1044
1045 @param Str The string representative of input device.
1046 @param DevPath The input device path structure.
1047 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1048 of the display node is used, where applicable. If DisplayOnly
1049 is FALSE, then the longer text representation of the display node
1050 is used.
1051 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1052 representation for a device node can be used, where applicable.
1053
1054 **/
1055 VOID
1056 DevPathToTextIPv6 (
1057 IN OUT POOL_PRINT *Str,
1058 IN VOID *DevPath,
1059 IN BOOLEAN DisplayOnly,
1060 IN BOOLEAN AllowShortcuts
1061 )
1062 {
1063 IPv6_DEVICE_PATH *IPDevPath;
1064
1065 IPDevPath = DevPath;
1066 if (DisplayOnly) {
1067 CatPrint (
1068 Str,
1069 L"IPv6(%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x)",
1070 IPDevPath->RemoteIpAddress.Addr[0],
1071 IPDevPath->RemoteIpAddress.Addr[1],
1072 IPDevPath->RemoteIpAddress.Addr[2],
1073 IPDevPath->RemoteIpAddress.Addr[3],
1074 IPDevPath->RemoteIpAddress.Addr[4],
1075 IPDevPath->RemoteIpAddress.Addr[5],
1076 IPDevPath->RemoteIpAddress.Addr[6],
1077 IPDevPath->RemoteIpAddress.Addr[7],
1078 IPDevPath->RemoteIpAddress.Addr[8],
1079 IPDevPath->RemoteIpAddress.Addr[9],
1080 IPDevPath->RemoteIpAddress.Addr[10],
1081 IPDevPath->RemoteIpAddress.Addr[11],
1082 IPDevPath->RemoteIpAddress.Addr[12],
1083 IPDevPath->RemoteIpAddress.Addr[13],
1084 IPDevPath->RemoteIpAddress.Addr[14],
1085 IPDevPath->RemoteIpAddress.Addr[15]
1086 );
1087 return ;
1088 }
1089
1090 CatPrint (
1091 Str,
1092 L"IPv6(%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x,%s,%s,%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x)",
1093 IPDevPath->RemoteIpAddress.Addr[0],
1094 IPDevPath->RemoteIpAddress.Addr[1],
1095 IPDevPath->RemoteIpAddress.Addr[2],
1096 IPDevPath->RemoteIpAddress.Addr[3],
1097 IPDevPath->RemoteIpAddress.Addr[4],
1098 IPDevPath->RemoteIpAddress.Addr[5],
1099 IPDevPath->RemoteIpAddress.Addr[6],
1100 IPDevPath->RemoteIpAddress.Addr[7],
1101 IPDevPath->RemoteIpAddress.Addr[8],
1102 IPDevPath->RemoteIpAddress.Addr[9],
1103 IPDevPath->RemoteIpAddress.Addr[10],
1104 IPDevPath->RemoteIpAddress.Addr[11],
1105 IPDevPath->RemoteIpAddress.Addr[12],
1106 IPDevPath->RemoteIpAddress.Addr[13],
1107 IPDevPath->RemoteIpAddress.Addr[14],
1108 IPDevPath->RemoteIpAddress.Addr[15],
1109 IPDevPath->Protocol ? L"TCP" : L"UDP",
1110 (IPDevPath->StaticIpAddress == TRUE) ? L"Static" : L"DHCP",
1111 IPDevPath->LocalIpAddress.Addr[0],
1112 IPDevPath->LocalIpAddress.Addr[1],
1113 IPDevPath->LocalIpAddress.Addr[2],
1114 IPDevPath->LocalIpAddress.Addr[3],
1115 IPDevPath->LocalIpAddress.Addr[4],
1116 IPDevPath->LocalIpAddress.Addr[5],
1117 IPDevPath->LocalIpAddress.Addr[6],
1118 IPDevPath->LocalIpAddress.Addr[7],
1119 IPDevPath->LocalIpAddress.Addr[8],
1120 IPDevPath->LocalIpAddress.Addr[9],
1121 IPDevPath->LocalIpAddress.Addr[10],
1122 IPDevPath->LocalIpAddress.Addr[11],
1123 IPDevPath->LocalIpAddress.Addr[12],
1124 IPDevPath->LocalIpAddress.Addr[13],
1125 IPDevPath->LocalIpAddress.Addr[14],
1126 IPDevPath->LocalIpAddress.Addr[15]
1127 );
1128 }
1129
1130 /**
1131 Converts an Infini Band device path structure to its string representative.
1132
1133 @param Str The string representative of input device.
1134 @param DevPath The input device path structure.
1135 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1136 of the display node is used, where applicable. If DisplayOnly
1137 is FALSE, then the longer text representation of the display node
1138 is used.
1139 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1140 representation for a device node can be used, where applicable.
1141
1142 **/
1143 VOID
1144 DevPathToTextInfiniBand (
1145 IN OUT POOL_PRINT *Str,
1146 IN VOID *DevPath,
1147 IN BOOLEAN DisplayOnly,
1148 IN BOOLEAN AllowShortcuts
1149 )
1150 {
1151 INFINIBAND_DEVICE_PATH *InfiniBand;
1152
1153 InfiniBand = DevPath;
1154 CatPrint (
1155 Str,
1156 L"Infiniband(0x%x,%g,0x%lx,0x%lx,0x%lx)",
1157 InfiniBand->ResourceFlags,
1158 InfiniBand->PortGid,
1159 InfiniBand->ServiceId,
1160 InfiniBand->TargetPortId,
1161 InfiniBand->DeviceId
1162 );
1163 }
1164
1165 /**
1166 Converts a UART device path structure to its string representative.
1167
1168 @param Str The string representative of input device.
1169 @param DevPath The input device path structure.
1170 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1171 of the display node is used, where applicable. If DisplayOnly
1172 is FALSE, then the longer text representation of the display node
1173 is used.
1174 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1175 representation for a device node can be used, where applicable.
1176
1177 **/
1178 VOID
1179 DevPathToTextUart (
1180 IN OUT POOL_PRINT *Str,
1181 IN VOID *DevPath,
1182 IN BOOLEAN DisplayOnly,
1183 IN BOOLEAN AllowShortcuts
1184 )
1185 {
1186 UART_DEVICE_PATH *Uart;
1187 CHAR8 Parity;
1188
1189 Uart = DevPath;
1190 switch (Uart->Parity) {
1191 case 0:
1192 Parity = 'D';
1193 break;
1194
1195 case 1:
1196 Parity = 'N';
1197 break;
1198
1199 case 2:
1200 Parity = 'E';
1201 break;
1202
1203 case 3:
1204 Parity = 'O';
1205 break;
1206
1207 case 4:
1208 Parity = 'M';
1209 break;
1210
1211 case 5:
1212 Parity = 'S';
1213 break;
1214
1215 default:
1216 Parity = 'x';
1217 break;
1218 }
1219
1220 if (Uart->BaudRate == 0) {
1221 CatPrint (Str, L"Uart(DEFAULT,");
1222 } else {
1223 CatPrint (Str, L"Uart(%ld,", Uart->BaudRate);
1224 }
1225
1226 if (Uart->DataBits == 0) {
1227 CatPrint (Str, L"DEFAULT,");
1228 } else {
1229 CatPrint (Str, L"%d,", Uart->DataBits);
1230 }
1231
1232 CatPrint (Str, L"%c,", Parity);
1233
1234 switch (Uart->StopBits) {
1235 case 0:
1236 CatPrint (Str, L"D)");
1237 break;
1238
1239 case 1:
1240 CatPrint (Str, L"1)");
1241 break;
1242
1243 case 2:
1244 CatPrint (Str, L"1.5)");
1245 break;
1246
1247 case 3:
1248 CatPrint (Str, L"2)");
1249 break;
1250
1251 default:
1252 CatPrint (Str, L"x)");
1253 break;
1254 }
1255 }
1256
1257 /**
1258 Converts an iSCSI device path structure to its string representative.
1259
1260 @param Str The string representative of input device.
1261 @param DevPath The input device path structure.
1262 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1263 of the display node is used, where applicable. If DisplayOnly
1264 is FALSE, then the longer text representation of the display node
1265 is used.
1266 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1267 representation for a device node can be used, where applicable.
1268
1269 **/
1270 VOID
1271 DevPathToTextiSCSI (
1272 IN OUT POOL_PRINT *Str,
1273 IN VOID *DevPath,
1274 IN BOOLEAN DisplayOnly,
1275 IN BOOLEAN AllowShortcuts
1276 )
1277 {
1278 ISCSI_DEVICE_PATH_WITH_NAME *ISCSIDevPath;
1279 UINT16 Options;
1280
1281 ISCSIDevPath = DevPath;
1282 CatPrint (
1283 Str,
1284 L"iSCSI(%a,0x%x,0x%lx,",
1285 ISCSIDevPath->iSCSITargetName,
1286 ISCSIDevPath->TargetPortalGroupTag,
1287 ISCSIDevPath->Lun
1288 );
1289
1290 Options = ISCSIDevPath->LoginOption;
1291 CatPrint (Str, L"%s,", (((Options >> 1) & 0x0001) != 0) ? L"CRC32C" : L"None");
1292 CatPrint (Str, L"%s,", (((Options >> 3) & 0x0001) != 0) ? L"CRC32C" : L"None");
1293 if (((Options >> 11) & 0x0001) != 0) {
1294 CatPrint (Str, L"%s,", L"None");
1295 } else if (((Options >> 12) & 0x0001) != 0) {
1296 CatPrint (Str, L"%s,", L"CHAP_UNI");
1297 } else {
1298 CatPrint (Str, L"%s,", L"CHAP_BI");
1299
1300 }
1301
1302 CatPrint (Str, L"%s)", (ISCSIDevPath->NetworkProtocol == 0) ? L"TCP" : L"reserved");
1303 }
1304
1305 /**
1306 Converts a Hard drive device path structure to its string representative.
1307
1308 @param Str The string representative of input device.
1309 @param DevPath The input device path structure.
1310 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1311 of the display node is used, where applicable. If DisplayOnly
1312 is FALSE, then the longer text representation of the display node
1313 is used.
1314 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1315 representation for a device node can be used, where applicable.
1316
1317 **/
1318 VOID
1319 DevPathToTextHardDrive (
1320 IN OUT POOL_PRINT *Str,
1321 IN VOID *DevPath,
1322 IN BOOLEAN DisplayOnly,
1323 IN BOOLEAN AllowShortcuts
1324 )
1325 {
1326 HARDDRIVE_DEVICE_PATH *Hd;
1327
1328 Hd = DevPath;
1329 switch (Hd->SignatureType) {
1330 case SIGNATURE_TYPE_MBR:
1331 CatPrint (
1332 Str,
1333 L"HD(%d,%s,0x%08x,",
1334 Hd->PartitionNumber,
1335 L"MBR",
1336 *((UINT32 *) (&(Hd->Signature[0])))
1337 );
1338 break;
1339
1340 case SIGNATURE_TYPE_GUID:
1341 CatPrint (
1342 Str,
1343 L"HD(%d,%s,%g,",
1344 Hd->PartitionNumber,
1345 L"GPT",
1346 (EFI_GUID *) &(Hd->Signature[0])
1347 );
1348 break;
1349
1350 default:
1351 CatPrint (
1352 Str,
1353 L"HD(%d,%d,0,",
1354 Hd->PartitionNumber,
1355 Hd->SignatureType
1356 );
1357 break;
1358 }
1359
1360 CatPrint (Str, L"0x%lx,0x%lx)", Hd->PartitionStart, Hd->PartitionSize);
1361 }
1362
1363 /**
1364 Converts a CDROM device path structure to its string representative.
1365
1366 @param Str The string representative of input device.
1367 @param DevPath The input device path structure.
1368 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1369 of the display node is used, where applicable. If DisplayOnly
1370 is FALSE, then the longer text representation of the display node
1371 is used.
1372 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1373 representation for a device node can be used, where applicable.
1374
1375 **/
1376 VOID
1377 DevPathToTextCDROM (
1378 IN OUT POOL_PRINT *Str,
1379 IN VOID *DevPath,
1380 IN BOOLEAN DisplayOnly,
1381 IN BOOLEAN AllowShortcuts
1382 )
1383 {
1384 CDROM_DEVICE_PATH *Cd;
1385
1386 Cd = DevPath;
1387 if (DisplayOnly) {
1388 CatPrint (Str, L"CDROM(0x%x)", Cd->BootEntry);
1389 return ;
1390 }
1391
1392 CatPrint (Str, L"CDROM(0x%x,0x%lx,0x%lx)", Cd->BootEntry, Cd->PartitionStart, Cd->PartitionSize);
1393 }
1394
1395 /**
1396 Converts a File device path structure to its string representative.
1397
1398 @param Str The string representative of input device.
1399 @param DevPath The input device path structure.
1400 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1401 of the display node is used, where applicable. If DisplayOnly
1402 is FALSE, then the longer text representation of the display node
1403 is used.
1404 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1405 representation for a device node can be used, where applicable.
1406
1407 **/
1408 VOID
1409 DevPathToTextFilePath (
1410 IN OUT POOL_PRINT *Str,
1411 IN VOID *DevPath,
1412 IN BOOLEAN DisplayOnly,
1413 IN BOOLEAN AllowShortcuts
1414 )
1415 {
1416 FILEPATH_DEVICE_PATH *Fp;
1417
1418 Fp = DevPath;
1419 CatPrint (Str, L"%s", Fp->PathName);
1420 }
1421
1422 /**
1423 Converts a Media protocol device path structure to its string representative.
1424
1425 @param Str The string representative of input device.
1426 @param DevPath The input device path structure.
1427 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1428 of the display node is used, where applicable. If DisplayOnly
1429 is FALSE, then the longer text representation of the display node
1430 is used.
1431 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1432 representation for a device node can be used, where applicable.
1433
1434 **/
1435 VOID
1436 DevPathToTextMediaProtocol (
1437 IN OUT POOL_PRINT *Str,
1438 IN VOID *DevPath,
1439 IN BOOLEAN DisplayOnly,
1440 IN BOOLEAN AllowShortcuts
1441 )
1442 {
1443 MEDIA_PROTOCOL_DEVICE_PATH *MediaProt;
1444
1445 MediaProt = DevPath;
1446 CatPrint (Str, L"Media(%g)", &MediaProt->Protocol);
1447 }
1448
1449 /**
1450 Converts a Firmware Volume device path structure to its string representative.
1451
1452 @param Str The string representative of input device.
1453 @param DevPath The input device path structure.
1454 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1455 of the display node is used, where applicable. If DisplayOnly
1456 is FALSE, then the longer text representation of the display node
1457 is used.
1458 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1459 representation for a device node can be used, where applicable.
1460
1461 **/
1462 VOID
1463 DevPathToTextFv (
1464 IN OUT POOL_PRINT *Str,
1465 IN VOID *DevPath,
1466 IN BOOLEAN DisplayOnly,
1467 IN BOOLEAN AllowShortcuts
1468 )
1469 {
1470 MEDIA_FW_VOL_DEVICE_PATH *Fv;
1471
1472 Fv = DevPath;
1473 CatPrint (Str, L"Fv(%g)", &Fv->FvName);
1474 }
1475
1476 /**
1477 Converts a Firmware Volume File device path structure to its string representative.
1478
1479 @param Str The string representative of input device.
1480 @param DevPath The input device path structure.
1481 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1482 of the display node is used, where applicable. If DisplayOnly
1483 is FALSE, then the longer text representation of the display node
1484 is used.
1485 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1486 representation for a device node can be used, where applicable.
1487
1488 **/
1489 VOID
1490 DevPathToTextFvFile (
1491 IN OUT POOL_PRINT *Str,
1492 IN VOID *DevPath,
1493 IN BOOLEAN DisplayOnly,
1494 IN BOOLEAN AllowShortcuts
1495 )
1496 {
1497 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFile;
1498
1499 FvFile = DevPath;
1500 CatPrint (Str, L"FvFile(%g)", &FvFile->FvFileName);
1501 }
1502
1503 /**
1504 Converts a BIOS Boot Specification device path structure to its string representative.
1505
1506 @param Str The string representative of input device.
1507 @param DevPath The input device path structure.
1508 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1509 of the display node is used, where applicable. If DisplayOnly
1510 is FALSE, then the longer text representation of the display node
1511 is used.
1512 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1513 representation for a device node can be used, where applicable.
1514
1515 **/
1516 VOID
1517 DevPathToTextBBS (
1518 IN OUT POOL_PRINT *Str,
1519 IN VOID *DevPath,
1520 IN BOOLEAN DisplayOnly,
1521 IN BOOLEAN AllowShortcuts
1522 )
1523 {
1524 BBS_BBS_DEVICE_PATH *Bbs;
1525 CHAR16 *Type;
1526
1527 Bbs = DevPath;
1528 switch (Bbs->DeviceType) {
1529 case BBS_TYPE_FLOPPY:
1530 Type = L"Floppy";
1531 break;
1532
1533 case BBS_TYPE_HARDDRIVE:
1534 Type = L"HD";
1535 break;
1536
1537 case BBS_TYPE_CDROM:
1538 Type = L"CDROM";
1539 break;
1540
1541 case BBS_TYPE_PCMCIA:
1542 Type = L"PCMCIA";
1543 break;
1544
1545 case BBS_TYPE_USB:
1546 Type = L"USB";
1547 break;
1548
1549 case BBS_TYPE_EMBEDDED_NETWORK:
1550 Type = L"Network";
1551 break;
1552
1553 default:
1554 Type = NULL;
1555 break;
1556 }
1557
1558 if (Type != NULL) {
1559 CatPrint (Str, L"BBS(%s,%a", Type, Bbs->String);
1560 } else {
1561 CatPrint (Str, L"BBS(0x%x,%a", Bbs->DeviceType, Bbs->String);
1562 }
1563
1564 if (DisplayOnly) {
1565 CatPrint (Str, L")");
1566 return ;
1567 }
1568
1569 CatPrint (Str, L",0x%x)", Bbs->StatusFlag);
1570 }
1571
1572 /**
1573 Converts an End-of-Device-Path structure to its string representative.
1574
1575 @param Str The string representative of input device.
1576 @param DevPath The input device path structure.
1577 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1578 of the display node is used, where applicable. If DisplayOnly
1579 is FALSE, then the longer text representation of the display node
1580 is used.
1581 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1582 representation for a device node can be used, where applicable.
1583
1584 **/
1585 VOID
1586 DevPathToTextEndInstance (
1587 IN OUT POOL_PRINT *Str,
1588 IN VOID *DevPath,
1589 IN BOOLEAN DisplayOnly,
1590 IN BOOLEAN AllowShortcuts
1591 )
1592 {
1593 CatPrint (Str, L",");
1594 }
1595
1596 /**
1597 Converts an unknown device path structure to its string representative.
1598
1599 @param Str The string representative of input device.
1600 @param DevPath The input device path structure.
1601 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1602 of the display node is used, where applicable. If DisplayOnly
1603 is FALSE, then the longer text representation of the display node
1604 is used.
1605 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1606 representation for a device node can be used, where applicable.
1607
1608 **/
1609 VOID
1610 DevPathToTextNodeUnknown (
1611 IN OUT POOL_PRINT *Str,
1612 IN VOID *DevPath,
1613 IN BOOLEAN DisplayOnly,
1614 IN BOOLEAN AllowShortcuts
1615 )
1616 {
1617 CatPrint (Str, L"?");
1618 }
1619
1620 GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_TABLE DevPathToTextTable[] = {
1621 {HARDWARE_DEVICE_PATH, HW_PCI_DP, DevPathToTextPci},
1622 {HARDWARE_DEVICE_PATH, HW_PCCARD_DP, DevPathToTextPccard},
1623 {HARDWARE_DEVICE_PATH, HW_MEMMAP_DP, DevPathToTextMemMap},
1624 {HARDWARE_DEVICE_PATH, HW_VENDOR_DP, DevPathToTextVendor},
1625 {HARDWARE_DEVICE_PATH, HW_CONTROLLER_DP, DevPathToTextController},
1626 {ACPI_DEVICE_PATH, ACPI_DP, DevPathToTextAcpi},
1627 {ACPI_DEVICE_PATH, ACPI_EXTENDED_DP, DevPathToTextAcpiEx},
1628 {ACPI_DEVICE_PATH, ACPI_ADR_DP, DevPathToTextAcpiAdr},
1629 {MESSAGING_DEVICE_PATH, MSG_ATAPI_DP, DevPathToTextAtapi},
1630 {MESSAGING_DEVICE_PATH, MSG_SCSI_DP, DevPathToTextScsi},
1631 {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNEL_DP, DevPathToTextFibre},
1632 {MESSAGING_DEVICE_PATH, MSG_1394_DP, DevPathToText1394},
1633 {MESSAGING_DEVICE_PATH, MSG_USB_DP, DevPathToTextUsb},
1634 {MESSAGING_DEVICE_PATH, MSG_USB_WWID_DP, DevPathToTextUsbWWID},
1635 {MESSAGING_DEVICE_PATH, MSG_DEVICE_LOGICAL_UNIT_DP, DevPathToTextLogicalUnit},
1636 {MESSAGING_DEVICE_PATH, MSG_USB_CLASS_DP, DevPathToTextUsbClass},
1637 {MESSAGING_DEVICE_PATH, MSG_SATA_DP, DevPathToTextSata},
1638 {MESSAGING_DEVICE_PATH, MSG_I2O_DP, DevPathToTextI2O},
1639 {MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP, DevPathToTextMacAddr},
1640 {MESSAGING_DEVICE_PATH, MSG_IPv4_DP, DevPathToTextIPv4},
1641 {MESSAGING_DEVICE_PATH, MSG_IPv6_DP, DevPathToTextIPv6},
1642 {MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP, DevPathToTextInfiniBand},
1643 {MESSAGING_DEVICE_PATH, MSG_UART_DP, DevPathToTextUart},
1644 {MESSAGING_DEVICE_PATH, MSG_VENDOR_DP, DevPathToTextVendor},
1645 {MESSAGING_DEVICE_PATH, MSG_ISCSI_DP, DevPathToTextiSCSI},
1646 {MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP, DevPathToTextHardDrive},
1647 {MEDIA_DEVICE_PATH, MEDIA_CDROM_DP, DevPathToTextCDROM},
1648 {MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP, DevPathToTextVendor},
1649 {MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP, DevPathToTextFilePath},
1650 {MEDIA_DEVICE_PATH, MEDIA_PROTOCOL_DP, DevPathToTextMediaProtocol},
1651 {MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP, DevPathToTextFilePath},
1652 {MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_VOL_DP, DevPathToTextFv},
1653 {MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_FILE_DP, DevPathToTextFvFile},
1654 {BBS_DEVICE_PATH, BBS_BBS_DP, DevPathToTextBBS},
1655 {END_DEVICE_PATH_TYPE, END_INSTANCE_DEVICE_PATH_SUBTYPE, DevPathToTextEndInstance},
1656 {0, 0, NULL}
1657 };
1658
1659 /**
1660 Converts a device node to its string representation.
1661
1662 @param DeviceNode A Pointer to the device node to be converted.
1663 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1664 of the display node is used, where applicable. If DisplayOnly
1665 is FALSE, then the longer text representation of the display node
1666 is used.
1667 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1668 representation for a device node can be used, where applicable.
1669
1670 @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
1671 is NULL or there was insufficient memory.
1672
1673 **/
1674 CHAR16 *
1675 EFIAPI
1676 ConvertDeviceNodeToText (
1677 IN CONST EFI_DEVICE_PATH_PROTOCOL *DeviceNode,
1678 IN BOOLEAN DisplayOnly,
1679 IN BOOLEAN AllowShortcuts
1680 )
1681 {
1682 POOL_PRINT Str;
1683 UINTN Index;
1684 UINTN NewSize;
1685 VOID (*DumpNode)(POOL_PRINT *, VOID *, BOOLEAN, BOOLEAN);
1686
1687 if (DeviceNode == NULL) {
1688 return NULL;
1689 }
1690
1691 ZeroMem (&Str, sizeof (Str));
1692
1693 //
1694 // Process the device path node
1695 //
1696 DumpNode = NULL;
1697 for (Index = 0; DevPathToTextTable[Index].Function != NULL; Index++) {
1698 if (DevicePathType (DeviceNode) == DevPathToTextTable[Index].Type &&
1699 DevicePathSubType (DeviceNode) == DevPathToTextTable[Index].SubType
1700 ) {
1701 DumpNode = DevPathToTextTable[Index].Function;
1702 break;
1703 }
1704 }
1705 //
1706 // If not found, use a generic function
1707 //
1708 if (DumpNode == NULL) {
1709 DumpNode = DevPathToTextNodeUnknown;
1710 }
1711
1712 //
1713 // Print this node
1714 //
1715 DumpNode (&Str, (VOID *) DeviceNode, DisplayOnly, AllowShortcuts);
1716
1717 //
1718 // Shrink pool used for string allocation
1719 //
1720 NewSize = (Str.Len + 1) * sizeof (CHAR16);
1721 Str.Str = ReallocatePool (NewSize, NewSize, Str.Str);
1722 ASSERT (Str.Str != NULL);
1723 Str.Str[Str.Len] = 0;
1724 return Str.Str;
1725 }
1726
1727 /**
1728 Converts a device path to its text representation.
1729
1730 @param DevicePath A Pointer to the device to be converted.
1731 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1732 of the display node is used, where applicable. If DisplayOnly
1733 is FALSE, then the longer text representation of the display node
1734 is used.
1735 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1736 representation for a device node can be used, where applicable.
1737
1738 @return A pointer to the allocated text representation of the device path or
1739 NULL if DeviceNode is NULL or there was insufficient memory.
1740
1741 **/
1742 CHAR16 *
1743 EFIAPI
1744 ConvertDevicePathToText (
1745 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
1746 IN BOOLEAN DisplayOnly,
1747 IN BOOLEAN AllowShortcuts
1748 )
1749 {
1750 POOL_PRINT Str;
1751 EFI_DEVICE_PATH_PROTOCOL *DevPathNode;
1752 EFI_DEVICE_PATH_PROTOCOL *AlignedDevPathNode;
1753 UINTN Index;
1754 UINTN NewSize;
1755 VOID (*DumpNode) (POOL_PRINT *, VOID *, BOOLEAN, BOOLEAN);
1756
1757 if (DevicePath == NULL) {
1758 return NULL;
1759 }
1760
1761 ZeroMem (&Str, sizeof (Str));
1762
1763 //
1764 // Process each device path node
1765 //
1766 DevPathNode = (EFI_DEVICE_PATH_PROTOCOL *) DevicePath;
1767 while (!IsDevicePathEnd (DevPathNode)) {
1768 //
1769 // Find the handler to dump this device path node
1770 //
1771 DumpNode = NULL;
1772 for (Index = 0; DevPathToTextTable[Index].Function; Index += 1) {
1773
1774 if (DevicePathType (DevPathNode) == DevPathToTextTable[Index].Type &&
1775 DevicePathSubType (DevPathNode) == DevPathToTextTable[Index].SubType
1776 ) {
1777 DumpNode = DevPathToTextTable[Index].Function;
1778 break;
1779 }
1780 }
1781 //
1782 // If not found, use a generic function
1783 //
1784 if (!DumpNode) {
1785 DumpNode = DevPathToTextNodeUnknown;
1786 }
1787 //
1788 // Put a path seperator in if needed
1789 //
1790 if ((Str.Len != 0) && DumpNode != DevPathToTextEndInstance) {
1791 if (*(Str.Str + Str.Len / sizeof (CHAR16) - 1) != L',') {
1792 CatPrint (&Str, L"/");
1793 }
1794 }
1795
1796 AlignedDevPathNode = AllocateCopyPool (DevicePathNodeLength (DevPathNode), DevPathNode);
1797 //
1798 // Print this node of the device path
1799 //
1800 DumpNode (&Str, AlignedDevPathNode, DisplayOnly, AllowShortcuts);
1801 FreePool (AlignedDevPathNode);
1802
1803 //
1804 // Next device path node
1805 //
1806 DevPathNode = NextDevicePathNode (DevPathNode);
1807 }
1808
1809 NewSize = (Str.Len + 1) * sizeof (CHAR16);
1810 Str.Str = ReallocatePool (NewSize, NewSize, Str.Str);
1811 ASSERT (Str.Str != NULL);
1812 Str.Str[Str.Len] = 0;
1813 return Str.Str;
1814 }
EFI Development Kit II mirror for PVE