]> 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
1. Add UEFI 2.2 VLAN device path definition to MdePkg
[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 - 2009, 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)", (UINTN) Pci->Device, (UINTN) 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)", (UINTN) 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 (UINTN) 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 (UINTN) ((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,",(UINTN) (Info >> 8) & 0xff);
254 }
255 } else {
256 CatPrint (Str, L"0,0,0,0,");
257 }
258
259 CatPrint (Str, L"0x%x)", (UINTN) ((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", (UINTN) ((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 (UINTN) 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)", (UINTN) Acpi->UID);
348 break;
349
350 case 0x0604:
351 CatPrint (Str, L"Floppy(0x%x)", (UINTN) Acpi->UID);
352 break;
353
354 case 0x0301:
355 CatPrint (Str, L"Keyboard(0x%x)", (UINTN) Acpi->UID);
356 break;
357
358 case 0x0501:
359 CatPrint (Str, L"Serial(0x%x)", (UINTN) Acpi->UID);
360 break;
361
362 case 0x0401:
363 CatPrint (Str, L"ParallelPort(0x%x)", (UINTN) Acpi->UID);
364 break;
365
366 default:
367 CatPrint (Str, L"Acpi(PNP%04x,0x%x)", (UINTN) EISA_ID_TO_NUM (Acpi->HID), (UINTN) Acpi->UID);
368 break;
369 }
370 } else {
371 CatPrint (Str, L"Acpi(0x%08x,0x%x)", (UINTN) Acpi->HID, (UINTN) 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,", (UINTN) 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 (UINTN) 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", (UINTN) AcpiAdr->ADR);
521 for (Index = 0; Index < AdditionalAdrCount; Index++) {
522 CatPrint (Str, L",0x%x", (UINTN) *(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)", (UINTN) Atapi->Lun);
554 } else {
555 CatPrint (
556 Str,
557 L"Ata(%s,%s,0x%x)",
558 (Atapi->PrimarySecondary == 1) ? L"Secondary" : L"Primary",
559 (Atapi->SlaveMaster == 1) ? L"Slave" : L"Master",
560 (UINTN) 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)", (UINTN) Scsi->Pun, (UINTN) 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 (UINTN) UsbWWId->VendorId,
720 (UINTN) UsbWWId->ProductId,
721 (UINTN) 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)", (UINTN) 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 (UINTN) UsbClass->VendorId,
840 (UINTN) UsbClass->ProductId,
841 (UINTN) UsbClass->DeviceSubClass,
842 (UINTN) 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 (UINTN) UsbClass->VendorId,
853 (UINTN) UsbClass->ProductId,
854 (UINTN) 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 (UINTN) UsbClass->VendorId,
862 (UINTN) UsbClass->ProductId,
863 (UINTN) 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 (UINTN) UsbClass->VendorId,
871 (UINTN) UsbClass->ProductId,
872 (UINTN) 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 (UINTN) UsbClass->VendorId,
882 (UINTN) UsbClass->ProductId,
883 (UINTN) UsbClass->DeviceClass,
884 (UINTN) UsbClass->DeviceSubClass,
885 (UINTN) 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 if (Sata->PortMultiplierPortNumber & SATA_HBA_DIRECT_CONNECT_FLAG) {
914 CatPrint (
915 Str,
916 L"Sata(0x%x,0x%x)",
917 (UINTN) Sata->HBAPortNumber,
918 (UINTN) Sata->Lun
919 );
920 } else {
921 CatPrint (
922 Str,
923 L"Sata(0x%x,0x%x,0x%x)",
924 (UINTN) Sata->HBAPortNumber,
925 (UINTN) Sata->PortMultiplierPortNumber,
926 (UINTN) Sata->Lun
927 );
928 }
929 }
930
931 /**
932 Converts a I20 device path structure to its string representative.
933
934 @param Str The string representative of input device.
935 @param DevPath The input device path structure.
936 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
937 of the display node is used, where applicable. If DisplayOnly
938 is FALSE, then the longer text representation of the display node
939 is used.
940 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
941 representation for a device node can be used, where applicable.
942
943 **/
944 VOID
945 DevPathToTextI2O (
946 IN OUT POOL_PRINT *Str,
947 IN VOID *DevPath,
948 IN BOOLEAN DisplayOnly,
949 IN BOOLEAN AllowShortcuts
950 )
951 {
952 I2O_DEVICE_PATH *I2ODevPath;
953
954 I2ODevPath = DevPath;
955 CatPrint (Str, L"I2O(0x%x)", (UINTN) I2ODevPath->Tid);
956 }
957
958 /**
959 Converts a MAC address device path structure to its string representative.
960
961 @param Str The string representative of input device.
962 @param DevPath The input device path structure.
963 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
964 of the display node is used, where applicable. If DisplayOnly
965 is FALSE, then the longer text representation of the display node
966 is used.
967 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
968 representation for a device node can be used, where applicable.
969
970 **/
971 VOID
972 DevPathToTextMacAddr (
973 IN OUT POOL_PRINT *Str,
974 IN VOID *DevPath,
975 IN BOOLEAN DisplayOnly,
976 IN BOOLEAN AllowShortcuts
977 )
978 {
979 MAC_ADDR_DEVICE_PATH *MacDevPath;
980 UINTN HwAddressSize;
981 UINTN Index;
982
983 MacDevPath = DevPath;
984
985 HwAddressSize = sizeof (EFI_MAC_ADDRESS);
986 if (MacDevPath->IfType == 0x01 || MacDevPath->IfType == 0x00) {
987 HwAddressSize = 6;
988 }
989
990 CatPrint (Str, L"MAC(");
991
992 for (Index = 0; Index < HwAddressSize; Index++) {
993 CatPrint (Str, L"%02x", (UINTN) MacDevPath->MacAddress.Addr[Index]);
994 }
995
996 CatPrint (Str, L",0x%x)", (UINTN) MacDevPath->IfType);
997 }
998
999 /**
1000 Converts a IPv4 device path structure to its string representative.
1001
1002 @param Str The string representative of input device.
1003 @param DevPath The input device path structure.
1004 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1005 of the display node is used, where applicable. If DisplayOnly
1006 is FALSE, then the longer text representation of the display node
1007 is used.
1008 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1009 representation for a device node can be used, where applicable.
1010
1011 **/
1012 VOID
1013 DevPathToTextIPv4 (
1014 IN OUT POOL_PRINT *Str,
1015 IN VOID *DevPath,
1016 IN BOOLEAN DisplayOnly,
1017 IN BOOLEAN AllowShortcuts
1018 )
1019 {
1020 IPv4_DEVICE_PATH *IPDevPath;
1021
1022 IPDevPath = DevPath;
1023 if (DisplayOnly) {
1024 CatPrint (
1025 Str,
1026 L"IPv4(%d.%d.%d.%d)",
1027 (UINTN) IPDevPath->RemoteIpAddress.Addr[0],
1028 (UINTN) IPDevPath->RemoteIpAddress.Addr[1],
1029 (UINTN) IPDevPath->RemoteIpAddress.Addr[2],
1030 (UINTN) IPDevPath->RemoteIpAddress.Addr[3]
1031 );
1032 return ;
1033 }
1034
1035 CatPrint (
1036 Str,
1037 L"IPv4(%d.%d.%d.%d,%s,%s,%d.%d.%d.%d)",
1038 (UINTN) IPDevPath->RemoteIpAddress.Addr[0],
1039 (UINTN) IPDevPath->RemoteIpAddress.Addr[1],
1040 (UINTN) IPDevPath->RemoteIpAddress.Addr[2],
1041 (UINTN) IPDevPath->RemoteIpAddress.Addr[3],
1042 (IPDevPath->Protocol == 1) ? L"TCP" : L"UDP",
1043 IPDevPath->StaticIpAddress ? L"Static" : L"DHCP",
1044 (UINTN) IPDevPath->LocalIpAddress.Addr[0],
1045 (UINTN) IPDevPath->LocalIpAddress.Addr[1],
1046 (UINTN) IPDevPath->LocalIpAddress.Addr[2],
1047 (UINTN) IPDevPath->LocalIpAddress.Addr[3]
1048 );
1049 }
1050
1051 /**
1052 Converts a IPv6 device path structure to its string representative.
1053
1054 @param Str The string representative of input device.
1055 @param DevPath The input device path structure.
1056 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1057 of the display node is used, where applicable. If DisplayOnly
1058 is FALSE, then the longer text representation of the display node
1059 is used.
1060 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1061 representation for a device node can be used, where applicable.
1062
1063 **/
1064 VOID
1065 DevPathToTextIPv6 (
1066 IN OUT POOL_PRINT *Str,
1067 IN VOID *DevPath,
1068 IN BOOLEAN DisplayOnly,
1069 IN BOOLEAN AllowShortcuts
1070 )
1071 {
1072 IPv6_DEVICE_PATH *IPDevPath;
1073
1074 IPDevPath = DevPath;
1075 if (DisplayOnly) {
1076 CatPrint (
1077 Str,
1078 L"IPv6(%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x)",
1079 (UINTN) IPDevPath->RemoteIpAddress.Addr[0],
1080 (UINTN) IPDevPath->RemoteIpAddress.Addr[1],
1081 (UINTN) IPDevPath->RemoteIpAddress.Addr[2],
1082 (UINTN) IPDevPath->RemoteIpAddress.Addr[3],
1083 (UINTN) IPDevPath->RemoteIpAddress.Addr[4],
1084 (UINTN) IPDevPath->RemoteIpAddress.Addr[5],
1085 (UINTN) IPDevPath->RemoteIpAddress.Addr[6],
1086 (UINTN) IPDevPath->RemoteIpAddress.Addr[7],
1087 (UINTN) IPDevPath->RemoteIpAddress.Addr[8],
1088 (UINTN) IPDevPath->RemoteIpAddress.Addr[9],
1089 (UINTN) IPDevPath->RemoteIpAddress.Addr[10],
1090 (UINTN) IPDevPath->RemoteIpAddress.Addr[11],
1091 (UINTN) IPDevPath->RemoteIpAddress.Addr[12],
1092 (UINTN) IPDevPath->RemoteIpAddress.Addr[13],
1093 (UINTN) IPDevPath->RemoteIpAddress.Addr[14],
1094 (UINTN) IPDevPath->RemoteIpAddress.Addr[15]
1095 );
1096 return ;
1097 }
1098
1099 CatPrint (
1100 Str,
1101 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)",
1102 (UINTN) IPDevPath->RemoteIpAddress.Addr[0],
1103 (UINTN) IPDevPath->RemoteIpAddress.Addr[1],
1104 (UINTN) IPDevPath->RemoteIpAddress.Addr[2],
1105 (UINTN) IPDevPath->RemoteIpAddress.Addr[3],
1106 (UINTN) IPDevPath->RemoteIpAddress.Addr[4],
1107 (UINTN) IPDevPath->RemoteIpAddress.Addr[5],
1108 (UINTN) IPDevPath->RemoteIpAddress.Addr[6],
1109 (UINTN) IPDevPath->RemoteIpAddress.Addr[7],
1110 (UINTN) IPDevPath->RemoteIpAddress.Addr[8],
1111 (UINTN) IPDevPath->RemoteIpAddress.Addr[9],
1112 (UINTN) IPDevPath->RemoteIpAddress.Addr[10],
1113 (UINTN) IPDevPath->RemoteIpAddress.Addr[11],
1114 (UINTN) IPDevPath->RemoteIpAddress.Addr[12],
1115 (UINTN) IPDevPath->RemoteIpAddress.Addr[13],
1116 (UINTN) IPDevPath->RemoteIpAddress.Addr[14],
1117 (UINTN) IPDevPath->RemoteIpAddress.Addr[15],
1118 (IPDevPath->Protocol == 1) ? L"TCP" : L"UDP",
1119 IPDevPath->StaticIpAddress ? L"Static" : L"DHCP",
1120 (UINTN) IPDevPath->LocalIpAddress.Addr[0],
1121 (UINTN) IPDevPath->LocalIpAddress.Addr[1],
1122 (UINTN) IPDevPath->LocalIpAddress.Addr[2],
1123 (UINTN) IPDevPath->LocalIpAddress.Addr[3],
1124 (UINTN) IPDevPath->LocalIpAddress.Addr[4],
1125 (UINTN) IPDevPath->LocalIpAddress.Addr[5],
1126 (UINTN) IPDevPath->LocalIpAddress.Addr[6],
1127 (UINTN) IPDevPath->LocalIpAddress.Addr[7],
1128 (UINTN) IPDevPath->LocalIpAddress.Addr[8],
1129 (UINTN) IPDevPath->LocalIpAddress.Addr[9],
1130 (UINTN) IPDevPath->LocalIpAddress.Addr[10],
1131 (UINTN) IPDevPath->LocalIpAddress.Addr[11],
1132 (UINTN) IPDevPath->LocalIpAddress.Addr[12],
1133 (UINTN) IPDevPath->LocalIpAddress.Addr[13],
1134 (UINTN) IPDevPath->LocalIpAddress.Addr[14],
1135 (UINTN) IPDevPath->LocalIpAddress.Addr[15]
1136 );
1137 }
1138
1139 /**
1140 Converts an Infini Band device path structure to its string representative.
1141
1142 @param Str The string representative of input device.
1143 @param DevPath The input device path structure.
1144 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1145 of the display node is used, where applicable. If DisplayOnly
1146 is FALSE, then the longer text representation of the display node
1147 is used.
1148 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1149 representation for a device node can be used, where applicable.
1150
1151 **/
1152 VOID
1153 DevPathToTextInfiniBand (
1154 IN OUT POOL_PRINT *Str,
1155 IN VOID *DevPath,
1156 IN BOOLEAN DisplayOnly,
1157 IN BOOLEAN AllowShortcuts
1158 )
1159 {
1160 INFINIBAND_DEVICE_PATH *InfiniBand;
1161
1162 InfiniBand = DevPath;
1163 CatPrint (
1164 Str,
1165 L"Infiniband(0x%x,%g,0x%lx,0x%lx,0x%lx)",
1166 (UINTN) InfiniBand->ResourceFlags,
1167 InfiniBand->PortGid,
1168 InfiniBand->ServiceId,
1169 InfiniBand->TargetPortId,
1170 InfiniBand->DeviceId
1171 );
1172 }
1173
1174 /**
1175 Converts a UART device path structure to its string representative.
1176
1177 @param Str The string representative of input device.
1178 @param DevPath The input device path structure.
1179 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1180 of the display node is used, where applicable. If DisplayOnly
1181 is FALSE, then the longer text representation of the display node
1182 is used.
1183 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1184 representation for a device node can be used, where applicable.
1185
1186 **/
1187 VOID
1188 DevPathToTextUart (
1189 IN OUT POOL_PRINT *Str,
1190 IN VOID *DevPath,
1191 IN BOOLEAN DisplayOnly,
1192 IN BOOLEAN AllowShortcuts
1193 )
1194 {
1195 UART_DEVICE_PATH *Uart;
1196 CHAR8 Parity;
1197
1198 Uart = DevPath;
1199 switch (Uart->Parity) {
1200 case 0:
1201 Parity = 'D';
1202 break;
1203
1204 case 1:
1205 Parity = 'N';
1206 break;
1207
1208 case 2:
1209 Parity = 'E';
1210 break;
1211
1212 case 3:
1213 Parity = 'O';
1214 break;
1215
1216 case 4:
1217 Parity = 'M';
1218 break;
1219
1220 case 5:
1221 Parity = 'S';
1222 break;
1223
1224 default:
1225 Parity = 'x';
1226 break;
1227 }
1228
1229 if (Uart->BaudRate == 0) {
1230 CatPrint (Str, L"Uart(DEFAULT,");
1231 } else {
1232 CatPrint (Str, L"Uart(%ld,", Uart->BaudRate);
1233 }
1234
1235 if (Uart->DataBits == 0) {
1236 CatPrint (Str, L"DEFAULT,");
1237 } else {
1238 CatPrint (Str, L"%d,", (UINTN) Uart->DataBits);
1239 }
1240
1241 CatPrint (Str, L"%c,", Parity);
1242
1243 switch (Uart->StopBits) {
1244 case 0:
1245 CatPrint (Str, L"D)");
1246 break;
1247
1248 case 1:
1249 CatPrint (Str, L"1)");
1250 break;
1251
1252 case 2:
1253 CatPrint (Str, L"1.5)");
1254 break;
1255
1256 case 3:
1257 CatPrint (Str, L"2)");
1258 break;
1259
1260 default:
1261 CatPrint (Str, L"x)");
1262 break;
1263 }
1264 }
1265
1266 /**
1267 Converts an iSCSI device path structure to its string representative.
1268
1269 @param Str The string representative of input device.
1270 @param DevPath The input device path structure.
1271 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1272 of the display node is used, where applicable. If DisplayOnly
1273 is FALSE, then the longer text representation of the display node
1274 is used.
1275 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1276 representation for a device node can be used, where applicable.
1277
1278 **/
1279 VOID
1280 DevPathToTextiSCSI (
1281 IN OUT POOL_PRINT *Str,
1282 IN VOID *DevPath,
1283 IN BOOLEAN DisplayOnly,
1284 IN BOOLEAN AllowShortcuts
1285 )
1286 {
1287 ISCSI_DEVICE_PATH_WITH_NAME *ISCSIDevPath;
1288 UINT16 Options;
1289
1290 ISCSIDevPath = DevPath;
1291 CatPrint (
1292 Str,
1293 L"iSCSI(%a,0x%x,0x%lx,",
1294 ISCSIDevPath->TargetName,
1295 (UINTN) ISCSIDevPath->TargetPortalGroupTag,
1296 ISCSIDevPath->Lun
1297 );
1298
1299 Options = ISCSIDevPath->LoginOption;
1300 CatPrint (Str, L"%s,", (((Options >> 1) & 0x0001) != 0) ? L"CRC32C" : L"None");
1301 CatPrint (Str, L"%s,", (((Options >> 3) & 0x0001) != 0) ? L"CRC32C" : L"None");
1302 if (((Options >> 11) & 0x0001) != 0) {
1303 CatPrint (Str, L"%s,", L"None");
1304 } else if (((Options >> 12) & 0x0001) != 0) {
1305 CatPrint (Str, L"%s,", L"CHAP_UNI");
1306 } else {
1307 CatPrint (Str, L"%s,", L"CHAP_BI");
1308
1309 }
1310
1311 CatPrint (Str, L"%s)", (ISCSIDevPath->NetworkProtocol == 0) ? L"TCP" : L"reserved");
1312 }
1313
1314 /**
1315 Converts a VLAN device path structure to its string representative.
1316
1317 @param Str The string representative of input device.
1318 @param DevPath The input device path structure.
1319 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1320 of the display node is used, where applicable. If DisplayOnly
1321 is FALSE, then the longer text representation of the display node
1322 is used.
1323 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1324 representation for a device node can be used, where applicable.
1325
1326 **/
1327 VOID
1328 DevPathToTextVlan (
1329 IN OUT POOL_PRINT *Str,
1330 IN VOID *DevPath,
1331 IN BOOLEAN DisplayOnly,
1332 IN BOOLEAN AllowShortcuts
1333 )
1334 {
1335 VLAN_DEVICE_PATH *Vlan;
1336
1337 Vlan = DevPath;
1338 CatPrint (Str, L"Vlan(%d)", (UINTN) Vlan->VlanId);
1339 }
1340
1341 /**
1342 Converts a Hard drive device path structure to its string representative.
1343
1344 @param Str The string representative of input device.
1345 @param DevPath The input device path structure.
1346 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1347 of the display node is used, where applicable. If DisplayOnly
1348 is FALSE, then the longer text representation of the display node
1349 is used.
1350 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1351 representation for a device node can be used, where applicable.
1352
1353 **/
1354 VOID
1355 DevPathToTextHardDrive (
1356 IN OUT POOL_PRINT *Str,
1357 IN VOID *DevPath,
1358 IN BOOLEAN DisplayOnly,
1359 IN BOOLEAN AllowShortcuts
1360 )
1361 {
1362 HARDDRIVE_DEVICE_PATH *Hd;
1363
1364 Hd = DevPath;
1365 switch (Hd->SignatureType) {
1366 case SIGNATURE_TYPE_MBR:
1367 CatPrint (
1368 Str,
1369 L"HD(%d,%s,0x%08x,",
1370 (UINTN) Hd->PartitionNumber,
1371 L"MBR",
1372 (UINTN) *((UINT32 *) (&(Hd->Signature[0])))
1373 );
1374 break;
1375
1376 case SIGNATURE_TYPE_GUID:
1377 CatPrint (
1378 Str,
1379 L"HD(%d,%s,%g,",
1380 (UINTN) Hd->PartitionNumber,
1381 L"GPT",
1382 (EFI_GUID *) &(Hd->Signature[0])
1383 );
1384 break;
1385
1386 default:
1387 CatPrint (
1388 Str,
1389 L"HD(%d,%d,0,",
1390 (UINTN) Hd->PartitionNumber,
1391 (UINTN) Hd->SignatureType
1392 );
1393 break;
1394 }
1395
1396 CatPrint (Str, L"0x%lx,0x%lx)", Hd->PartitionStart, Hd->PartitionSize);
1397 }
1398
1399 /**
1400 Converts a CDROM device path structure to its string representative.
1401
1402 @param Str The string representative of input device.
1403 @param DevPath The input device path structure.
1404 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1405 of the display node is used, where applicable. If DisplayOnly
1406 is FALSE, then the longer text representation of the display node
1407 is used.
1408 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1409 representation for a device node can be used, where applicable.
1410
1411 **/
1412 VOID
1413 DevPathToTextCDROM (
1414 IN OUT POOL_PRINT *Str,
1415 IN VOID *DevPath,
1416 IN BOOLEAN DisplayOnly,
1417 IN BOOLEAN AllowShortcuts
1418 )
1419 {
1420 CDROM_DEVICE_PATH *Cd;
1421
1422 Cd = DevPath;
1423 if (DisplayOnly) {
1424 CatPrint (Str, L"CDROM(0x%x)", (UINTN) Cd->BootEntry);
1425 return ;
1426 }
1427
1428 CatPrint (Str, L"CDROM(0x%x,0x%lx,0x%lx)", (UINTN) Cd->BootEntry, Cd->PartitionStart, Cd->PartitionSize);
1429 }
1430
1431 /**
1432 Converts a File device path structure to its string representative.
1433
1434 @param Str The string representative of input device.
1435 @param DevPath The input device path structure.
1436 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1437 of the display node is used, where applicable. If DisplayOnly
1438 is FALSE, then the longer text representation of the display node
1439 is used.
1440 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1441 representation for a device node can be used, where applicable.
1442
1443 **/
1444 VOID
1445 DevPathToTextFilePath (
1446 IN OUT POOL_PRINT *Str,
1447 IN VOID *DevPath,
1448 IN BOOLEAN DisplayOnly,
1449 IN BOOLEAN AllowShortcuts
1450 )
1451 {
1452 FILEPATH_DEVICE_PATH *Fp;
1453
1454 Fp = DevPath;
1455 CatPrint (Str, L"%s", Fp->PathName);
1456 }
1457
1458 /**
1459 Converts a Media protocol device path structure to its string representative.
1460
1461 @param Str The string representative of input device.
1462 @param DevPath The input device path structure.
1463 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1464 of the display node is used, where applicable. If DisplayOnly
1465 is FALSE, then the longer text representation of the display node
1466 is used.
1467 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1468 representation for a device node can be used, where applicable.
1469
1470 **/
1471 VOID
1472 DevPathToTextMediaProtocol (
1473 IN OUT POOL_PRINT *Str,
1474 IN VOID *DevPath,
1475 IN BOOLEAN DisplayOnly,
1476 IN BOOLEAN AllowShortcuts
1477 )
1478 {
1479 MEDIA_PROTOCOL_DEVICE_PATH *MediaProt;
1480
1481 MediaProt = DevPath;
1482 CatPrint (Str, L"Media(%g)", &MediaProt->Protocol);
1483 }
1484
1485 /**
1486 Converts a Firmware Volume device path structure to its string representative.
1487
1488 @param Str The string representative of input device.
1489 @param DevPath The input device path structure.
1490 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1491 of the display node is used, where applicable. If DisplayOnly
1492 is FALSE, then the longer text representation of the display node
1493 is used.
1494 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1495 representation for a device node can be used, where applicable.
1496
1497 **/
1498 VOID
1499 DevPathToTextFv (
1500 IN OUT POOL_PRINT *Str,
1501 IN VOID *DevPath,
1502 IN BOOLEAN DisplayOnly,
1503 IN BOOLEAN AllowShortcuts
1504 )
1505 {
1506 MEDIA_FW_VOL_DEVICE_PATH *Fv;
1507
1508 Fv = DevPath;
1509 CatPrint (Str, L"Fv(%g)", &Fv->FvName);
1510 }
1511
1512 /**
1513 Converts a Firmware Volume File device path structure to its string representative.
1514
1515 @param Str The string representative of input device.
1516 @param DevPath The input device path structure.
1517 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1518 of the display node is used, where applicable. If DisplayOnly
1519 is FALSE, then the longer text representation of the display node
1520 is used.
1521 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1522 representation for a device node can be used, where applicable.
1523
1524 **/
1525 VOID
1526 DevPathToTextFvFile (
1527 IN OUT POOL_PRINT *Str,
1528 IN VOID *DevPath,
1529 IN BOOLEAN DisplayOnly,
1530 IN BOOLEAN AllowShortcuts
1531 )
1532 {
1533 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFile;
1534
1535 FvFile = DevPath;
1536 CatPrint (Str, L"FvFile(%g)", &FvFile->FvFileName);
1537 }
1538
1539 /**
1540 Converts a Relative Offset device path structure to its string representative.
1541
1542 @param Str The string representative of input device.
1543 @param DevPath The input device path structure.
1544 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1545 of the display node is used, where applicable. If DisplayOnly
1546 is FALSE, then the longer text representation of the display node
1547 is used.
1548 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1549 representation for a device node can be used, where applicable.
1550
1551 **/
1552 VOID
1553 DevPathRelativeOffsetRange (
1554 IN OUT POOL_PRINT *Str,
1555 IN VOID *DevPath,
1556 IN BOOLEAN DisplayOnly,
1557 IN BOOLEAN AllowShortcuts
1558 )
1559 {
1560 MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset;
1561
1562 Offset = DevPath;
1563 CatPrint (
1564 Str,
1565 L"Offset(%lx,%lx)",
1566 Offset->StartingOffset,
1567 Offset->EndingOffset
1568 );
1569 }
1570
1571 /**
1572 Converts a BIOS Boot Specification device path structure to its string representative.
1573
1574 @param Str The string representative of input device.
1575 @param DevPath The input device path structure.
1576 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1577 of the display node is used, where applicable. If DisplayOnly
1578 is FALSE, then the longer text representation of the display node
1579 is used.
1580 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1581 representation for a device node can be used, where applicable.
1582
1583 **/
1584 VOID
1585 DevPathToTextBBS (
1586 IN OUT POOL_PRINT *Str,
1587 IN VOID *DevPath,
1588 IN BOOLEAN DisplayOnly,
1589 IN BOOLEAN AllowShortcuts
1590 )
1591 {
1592 BBS_BBS_DEVICE_PATH *Bbs;
1593 CHAR16 *Type;
1594
1595 Bbs = DevPath;
1596 switch (Bbs->DeviceType) {
1597 case BBS_TYPE_FLOPPY:
1598 Type = L"Floppy";
1599 break;
1600
1601 case BBS_TYPE_HARDDRIVE:
1602 Type = L"HD";
1603 break;
1604
1605 case BBS_TYPE_CDROM:
1606 Type = L"CDROM";
1607 break;
1608
1609 case BBS_TYPE_PCMCIA:
1610 Type = L"PCMCIA";
1611 break;
1612
1613 case BBS_TYPE_USB:
1614 Type = L"USB";
1615 break;
1616
1617 case BBS_TYPE_EMBEDDED_NETWORK:
1618 Type = L"Network";
1619 break;
1620
1621 default:
1622 Type = NULL;
1623 break;
1624 }
1625
1626 if (Type != NULL) {
1627 CatPrint (Str, L"BBS(%s,%a", Type, Bbs->String);
1628 } else {
1629 CatPrint (Str, L"BBS(0x%x,%a", (UINTN) Bbs->DeviceType, Bbs->String);
1630 }
1631
1632 if (DisplayOnly) {
1633 CatPrint (Str, L")");
1634 return ;
1635 }
1636
1637 CatPrint (Str, L",0x%x)", (UINTN) Bbs->StatusFlag);
1638 }
1639
1640 /**
1641 Converts an End-of-Device-Path structure to its string representative.
1642
1643 @param Str The string representative of input device.
1644 @param DevPath The input device path structure.
1645 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1646 of the display node is used, where applicable. If DisplayOnly
1647 is FALSE, then the longer text representation of the display node
1648 is used.
1649 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1650 representation for a device node can be used, where applicable.
1651
1652 **/
1653 VOID
1654 DevPathToTextEndInstance (
1655 IN OUT POOL_PRINT *Str,
1656 IN VOID *DevPath,
1657 IN BOOLEAN DisplayOnly,
1658 IN BOOLEAN AllowShortcuts
1659 )
1660 {
1661 CatPrint (Str, L",");
1662 }
1663
1664 /**
1665 Converts an unknown device path structure to its string representative.
1666
1667 @param Str The string representative of input device.
1668 @param DevPath The input device path structure.
1669 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1670 of the display node is used, where applicable. If DisplayOnly
1671 is FALSE, then the longer text representation of the display node
1672 is used.
1673 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1674 representation for a device node can be used, where applicable.
1675
1676 **/
1677 VOID
1678 DevPathToTextNodeUnknown (
1679 IN OUT POOL_PRINT *Str,
1680 IN VOID *DevPath,
1681 IN BOOLEAN DisplayOnly,
1682 IN BOOLEAN AllowShortcuts
1683 )
1684 {
1685 CatPrint (Str, L"?");
1686 }
1687
1688 GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_TABLE DevPathToTextTable[] = {
1689 {HARDWARE_DEVICE_PATH, HW_PCI_DP, DevPathToTextPci},
1690 {HARDWARE_DEVICE_PATH, HW_PCCARD_DP, DevPathToTextPccard},
1691 {HARDWARE_DEVICE_PATH, HW_MEMMAP_DP, DevPathToTextMemMap},
1692 {HARDWARE_DEVICE_PATH, HW_VENDOR_DP, DevPathToTextVendor},
1693 {HARDWARE_DEVICE_PATH, HW_CONTROLLER_DP, DevPathToTextController},
1694 {ACPI_DEVICE_PATH, ACPI_DP, DevPathToTextAcpi},
1695 {ACPI_DEVICE_PATH, ACPI_EXTENDED_DP, DevPathToTextAcpiEx},
1696 {ACPI_DEVICE_PATH, ACPI_ADR_DP, DevPathToTextAcpiAdr},
1697 {MESSAGING_DEVICE_PATH, MSG_ATAPI_DP, DevPathToTextAtapi},
1698 {MESSAGING_DEVICE_PATH, MSG_SCSI_DP, DevPathToTextScsi},
1699 {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNEL_DP, DevPathToTextFibre},
1700 {MESSAGING_DEVICE_PATH, MSG_1394_DP, DevPathToText1394},
1701 {MESSAGING_DEVICE_PATH, MSG_USB_DP, DevPathToTextUsb},
1702 {MESSAGING_DEVICE_PATH, MSG_USB_WWID_DP, DevPathToTextUsbWWID},
1703 {MESSAGING_DEVICE_PATH, MSG_DEVICE_LOGICAL_UNIT_DP, DevPathToTextLogicalUnit},
1704 {MESSAGING_DEVICE_PATH, MSG_USB_CLASS_DP, DevPathToTextUsbClass},
1705 {MESSAGING_DEVICE_PATH, MSG_SATA_DP, DevPathToTextSata},
1706 {MESSAGING_DEVICE_PATH, MSG_I2O_DP, DevPathToTextI2O},
1707 {MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP, DevPathToTextMacAddr},
1708 {MESSAGING_DEVICE_PATH, MSG_IPv4_DP, DevPathToTextIPv4},
1709 {MESSAGING_DEVICE_PATH, MSG_IPv6_DP, DevPathToTextIPv6},
1710 {MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP, DevPathToTextInfiniBand},
1711 {MESSAGING_DEVICE_PATH, MSG_UART_DP, DevPathToTextUart},
1712 {MESSAGING_DEVICE_PATH, MSG_VENDOR_DP, DevPathToTextVendor},
1713 {MESSAGING_DEVICE_PATH, MSG_ISCSI_DP, DevPathToTextiSCSI},
1714 {MESSAGING_DEVICE_PATH, MSG_VLAN_DP, DevPathToTextVlan},
1715 {MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP, DevPathToTextHardDrive},
1716 {MEDIA_DEVICE_PATH, MEDIA_CDROM_DP, DevPathToTextCDROM},
1717 {MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP, DevPathToTextVendor},
1718 {MEDIA_DEVICE_PATH, MEDIA_PROTOCOL_DP, DevPathToTextMediaProtocol},
1719 {MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP, DevPathToTextFilePath},
1720 {MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_VOL_DP, DevPathToTextFv},
1721 {MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_FILE_DP, DevPathToTextFvFile},
1722 {MEDIA_DEVICE_PATH, MEDIA_RELATIVE_OFFSET_RANGE_DP, DevPathRelativeOffsetRange},
1723 {BBS_DEVICE_PATH, BBS_BBS_DP, DevPathToTextBBS},
1724 {END_DEVICE_PATH_TYPE, END_INSTANCE_DEVICE_PATH_SUBTYPE, DevPathToTextEndInstance},
1725 {0, 0, NULL}
1726 };
1727
1728 /**
1729 Converts a device node to its string representation.
1730
1731 @param DeviceNode A Pointer to the device node to be converted.
1732 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1733 of the display node is used, where applicable. If DisplayOnly
1734 is FALSE, then the longer text representation of the display node
1735 is used.
1736 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1737 representation for a device node can be used, where applicable.
1738
1739 @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
1740 is NULL or there was insufficient memory.
1741
1742 **/
1743 CHAR16 *
1744 EFIAPI
1745 ConvertDeviceNodeToText (
1746 IN CONST EFI_DEVICE_PATH_PROTOCOL *DeviceNode,
1747 IN BOOLEAN DisplayOnly,
1748 IN BOOLEAN AllowShortcuts
1749 )
1750 {
1751 POOL_PRINT Str;
1752 UINTN Index;
1753 UINTN NewSize;
1754 VOID (*DumpNode)(POOL_PRINT *, VOID *, BOOLEAN, BOOLEAN);
1755
1756 if (DeviceNode == NULL) {
1757 return NULL;
1758 }
1759
1760 ZeroMem (&Str, sizeof (Str));
1761
1762 //
1763 // Process the device path node
1764 //
1765 DumpNode = NULL;
1766 for (Index = 0; DevPathToTextTable[Index].Function != NULL; Index++) {
1767 if (DevicePathType (DeviceNode) == DevPathToTextTable[Index].Type &&
1768 DevicePathSubType (DeviceNode) == DevPathToTextTable[Index].SubType
1769 ) {
1770 DumpNode = DevPathToTextTable[Index].Function;
1771 break;
1772 }
1773 }
1774 //
1775 // If not found, use a generic function
1776 //
1777 if (DumpNode == NULL) {
1778 DumpNode = DevPathToTextNodeUnknown;
1779 }
1780
1781 //
1782 // Print this node
1783 //
1784 DumpNode (&Str, (VOID *) DeviceNode, DisplayOnly, AllowShortcuts);
1785
1786 //
1787 // Shrink pool used for string allocation
1788 //
1789 NewSize = (Str.Len + 1) * sizeof (CHAR16);
1790 Str.Str = ReallocatePool (NewSize, NewSize, Str.Str);
1791 ASSERT (Str.Str != NULL);
1792 Str.Str[Str.Len] = 0;
1793 return Str.Str;
1794 }
1795
1796 /**
1797 Converts a device path to its text representation.
1798
1799 @param DevicePath A Pointer to the device to be converted.
1800 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1801 of the display node is used, where applicable. If DisplayOnly
1802 is FALSE, then the longer text representation of the display node
1803 is used.
1804 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1805 representation for a device node can be used, where applicable.
1806
1807 @return A pointer to the allocated text representation of the device path or
1808 NULL if DeviceNode is NULL or there was insufficient memory.
1809
1810 **/
1811 CHAR16 *
1812 EFIAPI
1813 ConvertDevicePathToText (
1814 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
1815 IN BOOLEAN DisplayOnly,
1816 IN BOOLEAN AllowShortcuts
1817 )
1818 {
1819 POOL_PRINT Str;
1820 EFI_DEVICE_PATH_PROTOCOL *DevPathNode;
1821 EFI_DEVICE_PATH_PROTOCOL *AlignedDevPathNode;
1822 UINTN Index;
1823 UINTN NewSize;
1824 VOID (*DumpNode) (POOL_PRINT *, VOID *, BOOLEAN, BOOLEAN);
1825
1826 if (DevicePath == NULL) {
1827 return NULL;
1828 }
1829
1830 ZeroMem (&Str, sizeof (Str));
1831
1832 //
1833 // Process each device path node
1834 //
1835 DevPathNode = (EFI_DEVICE_PATH_PROTOCOL *) DevicePath;
1836 while (!IsDevicePathEnd (DevPathNode)) {
1837 //
1838 // Find the handler to dump this device path node
1839 //
1840 DumpNode = NULL;
1841 for (Index = 0; DevPathToTextTable[Index].Function != NULL; Index += 1) {
1842
1843 if (DevicePathType (DevPathNode) == DevPathToTextTable[Index].Type &&
1844 DevicePathSubType (DevPathNode) == DevPathToTextTable[Index].SubType
1845 ) {
1846 DumpNode = DevPathToTextTable[Index].Function;
1847 break;
1848 }
1849 }
1850 //
1851 // If not found, use a generic function
1852 //
1853 if (!DumpNode) {
1854 DumpNode = DevPathToTextNodeUnknown;
1855 }
1856 //
1857 // Put a path separator in if needed
1858 //
1859 if ((Str.Len != 0) && DumpNode != DevPathToTextEndInstance) {
1860 if (*(Str.Str + Str.Len / sizeof (CHAR16) - 1) != L',') {
1861 CatPrint (&Str, L"/");
1862 }
1863 }
1864
1865 AlignedDevPathNode = AllocateCopyPool (DevicePathNodeLength (DevPathNode), DevPathNode);
1866 //
1867 // Print this node of the device path
1868 //
1869 DumpNode (&Str, AlignedDevPathNode, DisplayOnly, AllowShortcuts);
1870 FreePool (AlignedDevPathNode);
1871
1872 //
1873 // Next device path node
1874 //
1875 DevPathNode = NextDevicePathNode (DevPathNode);
1876 }
1877
1878 NewSize = (Str.Len + 1) * sizeof (CHAR16);
1879 Str.Str = ReallocatePool (NewSize, NewSize, Str.Str);
1880 ASSERT (Str.Str != NULL);
1881 Str.Str[Str.Len] = 0;
1882 return Str.Str;
1883 }
EFI Development Kit II mirror for PVE