1 /** @file
2 DevicePathToText protocol as defined in the UEFI 2.0 specification.
3
4 (C) Copyright 2015 Hewlett-Packard Development Company, L.P.<BR>
5 Copyright (c) 2013 - 2015, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16 #include "UefiDevicePathLib.h"
17
18 /**
19 Concatenates a formatted unicode string to allocated pool. The caller must
20 free the resulting buffer.
21
22 @param Str Tracks the allocated pool, size in use, and
23 amount of pool allocated.
24 @param Fmt The format string
25 @param ... Variable arguments based on the format string.
26
27 @return Allocated buffer with the formatted string printed in it.
28 The caller must free the allocated buffer. The buffer
29 allocation is not packed.
30
31 **/
32 CHAR16 *
33 EFIAPI
UefiDevicePathLibCatPrint(IN OUT POOL_PRINT * Str,IN CHAR16 * Fmt,...)34 UefiDevicePathLibCatPrint (
35 IN OUT POOL_PRINT *Str,
36 IN CHAR16 *Fmt,
37 ...
38 )
39 {
40 UINTN Count;
41 VA_LIST Args;
42
43 VA_START (Args, Fmt);
44 Count = SPrintLength (Fmt, Args);
45
46 if ((Str->Count + (Count + 1)) * sizeof (CHAR16) > Str->Capacity) {
47 Str->Capacity = (Str->Count + (Count + 1) * 2) * sizeof (CHAR16);
48 Str->Str = ReallocatePool (
49 Str->Count * sizeof (CHAR16),
50 Str->Capacity,
51 Str->Str
52 );
53 ASSERT (Str->Str != NULL);
54 }
55 UnicodeVSPrint (&Str->Str[Str->Count], Str->Capacity - Str->Count * sizeof (CHAR16), Fmt, Args);
56 Str->Count += Count;
57
58 VA_END (Args);
59 return Str->Str;
60 }
61
62 /**
63 Converts a PCI device path structure to its string representative.
64
65 @param Str The string representative of input device.
66 @param DevPath The input device path structure.
67 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
68 of the display node is used, where applicable. If DisplayOnly
69 is FALSE, then the longer text representation of the display node
70 is used.
71 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
72 representation for a device node can be used, where applicable.
73
74 **/
75 VOID
DevPathToTextPci(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)76 DevPathToTextPci (
77 IN OUT POOL_PRINT *Str,
78 IN VOID *DevPath,
79 IN BOOLEAN DisplayOnly,
80 IN BOOLEAN AllowShortcuts
81 )
82 {
83 PCI_DEVICE_PATH *Pci;
84
85 Pci = DevPath;
86 UefiDevicePathLibCatPrint (Str, L"Pci(0x%x,0x%x)", Pci->Device, Pci->Function);
87 }
88
89 /**
90 Converts a PC Card device path structure to its string representative.
91
92 @param Str The string representative of input device.
93 @param DevPath The input device path structure.
94 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
95 of the display node is used, where applicable. If DisplayOnly
96 is FALSE, then the longer text representation of the display node
97 is used.
98 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
99 representation for a device node can be used, where applicable.
100
101 **/
102 VOID
DevPathToTextPccard(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)103 DevPathToTextPccard (
104 IN OUT POOL_PRINT *Str,
105 IN VOID *DevPath,
106 IN BOOLEAN DisplayOnly,
107 IN BOOLEAN AllowShortcuts
108 )
109 {
110 PCCARD_DEVICE_PATH *Pccard;
111
112 Pccard = DevPath;
113 UefiDevicePathLibCatPrint (Str, L"PcCard(0x%x)", Pccard->FunctionNumber);
114 }
115
116 /**
117 Converts a Memory Map device path structure to its string representative.
118
119 @param Str The string representative of input device.
120 @param DevPath The input device path structure.
121 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
122 of the display node is used, where applicable. If DisplayOnly
123 is FALSE, then the longer text representation of the display node
124 is used.
125 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
126 representation for a device node can be used, where applicable.
127
128 **/
129 VOID
DevPathToTextMemMap(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)130 DevPathToTextMemMap (
131 IN OUT POOL_PRINT *Str,
132 IN VOID *DevPath,
133 IN BOOLEAN DisplayOnly,
134 IN BOOLEAN AllowShortcuts
135 )
136 {
137 MEMMAP_DEVICE_PATH *MemMap;
138
139 MemMap = DevPath;
140 UefiDevicePathLibCatPrint (
141 Str,
142 L"MemoryMapped(0x%x,0x%lx,0x%lx)",
143 MemMap->MemoryType,
144 MemMap->StartingAddress,
145 MemMap->EndingAddress
146 );
147 }
148
149 /**
150 Converts a Vendor device path structure to its string representative.
151
152 @param Str The string representative of input device.
153 @param DevPath The input device path structure.
154 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
155 of the display node is used, where applicable. If DisplayOnly
156 is FALSE, then the longer text representation of the display node
157 is used.
158 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
159 representation for a device node can be used, where applicable.
160
161 **/
162 VOID
DevPathToTextVendor(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)163 DevPathToTextVendor (
164 IN OUT POOL_PRINT *Str,
165 IN VOID *DevPath,
166 IN BOOLEAN DisplayOnly,
167 IN BOOLEAN AllowShortcuts
168 )
169 {
170 VENDOR_DEVICE_PATH *Vendor;
171 CHAR16 *Type;
172 UINTN Index;
173 UINTN DataLength;
174 UINT32 FlowControlMap;
175 UINT16 Info;
176
177 Vendor = (VENDOR_DEVICE_PATH *) DevPath;
178 switch (DevicePathType (&Vendor->Header)) {
179 case HARDWARE_DEVICE_PATH:
180 Type = L"Hw";
181 break;
182
183 case MESSAGING_DEVICE_PATH:
184 Type = L"Msg";
185 if (AllowShortcuts) {
186 if (CompareGuid (&Vendor->Guid, &gEfiPcAnsiGuid)) {
187 UefiDevicePathLibCatPrint (Str, L"VenPcAnsi()");
188 return ;
189 } else if (CompareGuid (&Vendor->Guid, &gEfiVT100Guid)) {
190 UefiDevicePathLibCatPrint (Str, L"VenVt100()");
191 return ;
192 } else if (CompareGuid (&Vendor->Guid, &gEfiVT100PlusGuid)) {
193 UefiDevicePathLibCatPrint (Str, L"VenVt100Plus()");
194 return ;
195 } else if (CompareGuid (&Vendor->Guid, &gEfiVTUTF8Guid)) {
196 UefiDevicePathLibCatPrint (Str, L"VenUft8()");
197 return ;
198 } else if (CompareGuid (&Vendor->Guid, &gEfiUartDevicePathGuid)) {
199 FlowControlMap = (((UART_FLOW_CONTROL_DEVICE_PATH *) Vendor)->FlowControlMap);
200 switch (FlowControlMap & 0x00000003) {
201 case 0:
202 UefiDevicePathLibCatPrint (Str, L"UartFlowCtrl(%s)", L"None");
203 break;
204
205 case 1:
206 UefiDevicePathLibCatPrint (Str, L"UartFlowCtrl(%s)", L"Hardware");
207 break;
208
209 case 2:
210 UefiDevicePathLibCatPrint (Str, L"UartFlowCtrl(%s)", L"XonXoff");
211 break;
212
213 default:
214 break;
215 }
216
217 return ;
218 } else if (CompareGuid (&Vendor->Guid, &gEfiSasDevicePathGuid)) {
219 UefiDevicePathLibCatPrint (
220 Str,
221 L"SAS(0x%lx,0x%lx,0x%x,",
222 ((SAS_DEVICE_PATH *) Vendor)->SasAddress,
223 ((SAS_DEVICE_PATH *) Vendor)->Lun,
224 ((SAS_DEVICE_PATH *) Vendor)->RelativeTargetPort
225 );
226 Info = (((SAS_DEVICE_PATH *) Vendor)->DeviceTopology);
227 if (((Info & 0x0f) == 0) && ((Info & BIT7) == 0)) {
228 UefiDevicePathLibCatPrint (Str, L"NoTopology,0,0,0,");
229 } else if (((Info & 0x0f) <= 2) && ((Info & BIT7) == 0)) {
230 UefiDevicePathLibCatPrint (
231 Str,
232 L"%s,%s,%s,",
233 ((Info & BIT4) != 0) ? L"SATA" : L"SAS",
234 ((Info & BIT5) != 0) ? L"External" : L"Internal",
235 ((Info & BIT6) != 0) ? L"Expanded" : L"Direct"
236 );
237 if ((Info & 0x0f) == 1) {
238 UefiDevicePathLibCatPrint (Str, L"0,");
239 } else {
240 //
241 // Value 0x0 thru 0xFF -> Drive 1 thru Drive 256
242 //
243 UefiDevicePathLibCatPrint (Str, L"0x%x,", ((Info >> 8) & 0xff) + 1);
244 }
245 } else {
246 UefiDevicePathLibCatPrint (Str, L"0x%x,0,0,0,", Info);
247 }
248
249 UefiDevicePathLibCatPrint (Str, L"0x%x)", ((SAS_DEVICE_PATH *) Vendor)->Reserved);
250 return ;
251 } else if (CompareGuid (&Vendor->Guid, &gEfiDebugPortProtocolGuid)) {
252 UefiDevicePathLibCatPrint (Str, L"DebugPort()");
253 return ;
254 }
255 }
256 break;
257
258 case MEDIA_DEVICE_PATH:
259 Type = L"Media";
260 break;
261
262 default:
263 Type = L"?";
264 break;
265 }
266
267 DataLength = DevicePathNodeLength (&Vendor->Header) - sizeof (VENDOR_DEVICE_PATH);
268 UefiDevicePathLibCatPrint (Str, L"Ven%s(%g", Type, &Vendor->Guid);
269 if (DataLength != 0) {
270 UefiDevicePathLibCatPrint (Str, L",");
271 for (Index = 0; Index < DataLength; Index++) {
272 UefiDevicePathLibCatPrint (Str, L"%02x", ((VENDOR_DEVICE_PATH_WITH_DATA *) Vendor)->VendorDefinedData[Index]);
273 }
274 }
275
276 UefiDevicePathLibCatPrint (Str, L")");
277 }
278
279 /**
280 Converts a Controller device path structure to its string representative.
281
282 @param Str The string representative of input device.
283 @param DevPath The input device path structure.
284 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
285 of the display node is used, where applicable. If DisplayOnly
286 is FALSE, then the longer text representation of the display node
287 is used.
288 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
289 representation for a device node can be used, where applicable.
290
291 **/
292 VOID
DevPathToTextController(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)293 DevPathToTextController (
294 IN OUT POOL_PRINT *Str,
295 IN VOID *DevPath,
296 IN BOOLEAN DisplayOnly,
297 IN BOOLEAN AllowShortcuts
298 )
299 {
300 CONTROLLER_DEVICE_PATH *Controller;
301
302 Controller = DevPath;
303 UefiDevicePathLibCatPrint (
304 Str,
305 L"Ctrl(0x%x)",
306 Controller->ControllerNumber
307 );
308 }
309
310 /**
311 Converts a BMC device path structure to its string representative.
312
313 @param Str The string representative of input device.
314 @param DevPath The input device path structure.
315 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
316 of the display node is used, where applicable. If DisplayOnly
317 is FALSE, then the longer text representation of the display node
318 is used.
319 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
320 representation for a device node can be used, where applicable.
321
322 **/
323 VOID
DevPathToTextBmc(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)324 DevPathToTextBmc (
325 IN OUT POOL_PRINT *Str,
326 IN VOID *DevPath,
327 IN BOOLEAN DisplayOnly,
328 IN BOOLEAN AllowShortcuts
329 )
330 {
331 BMC_DEVICE_PATH *Bmc;
332
333 Bmc = DevPath;
334 UefiDevicePathLibCatPrint (
335 Str,
336 L"BMC(0x%x,0x%lx)",
337 Bmc->InterfaceType,
338 ReadUnaligned64 ((UINT64 *) (&Bmc->BaseAddress))
339 );
340 }
341
342 /**
343 Converts a ACPI device path structure to its string representative.
344
345 @param Str The string representative of input device.
346 @param DevPath The input device path structure.
347 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
348 of the display node is used, where applicable. If DisplayOnly
349 is FALSE, then the longer text representation of the display node
350 is used.
351 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
352 representation for a device node can be used, where applicable.
353
354 **/
355 VOID
DevPathToTextAcpi(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)356 DevPathToTextAcpi (
357 IN OUT POOL_PRINT *Str,
358 IN VOID *DevPath,
359 IN BOOLEAN DisplayOnly,
360 IN BOOLEAN AllowShortcuts
361 )
362 {
363 ACPI_HID_DEVICE_PATH *Acpi;
364
365 Acpi = DevPath;
366 if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
367 switch (EISA_ID_TO_NUM (Acpi->HID)) {
368 case 0x0a03:
369 UefiDevicePathLibCatPrint (Str, L"PciRoot(0x%x)", Acpi->UID);
370 break;
371
372 case 0x0a08:
373 UefiDevicePathLibCatPrint (Str, L"PcieRoot(0x%x)", Acpi->UID);
374 break;
375
376 case 0x0604:
377 UefiDevicePathLibCatPrint (Str, L"Floppy(0x%x)", Acpi->UID);
378 break;
379
380 case 0x0301:
381 UefiDevicePathLibCatPrint (Str, L"Keyboard(0x%x)", Acpi->UID);
382 break;
383
384 case 0x0501:
385 UefiDevicePathLibCatPrint (Str, L"Serial(0x%x)", Acpi->UID);
386 break;
387
388 case 0x0401:
389 UefiDevicePathLibCatPrint (Str, L"ParallelPort(0x%x)", Acpi->UID);
390 break;
391
392 default:
393 UefiDevicePathLibCatPrint (Str, L"Acpi(PNP%04x,0x%x)", EISA_ID_TO_NUM (Acpi->HID), Acpi->UID);
394 break;
395 }
396 } else {
397 UefiDevicePathLibCatPrint (Str, L"Acpi(0x%08x,0x%x)", Acpi->HID, Acpi->UID);
398 }
399 }
400
401 /**
402 Converts a ACPI extended HID device path structure to its string representative.
403
404 @param Str The string representative of input device.
405 @param DevPath The input device path structure.
406 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
407 of the display node is used, where applicable. If DisplayOnly
408 is FALSE, then the longer text representation of the display node
409 is used.
410 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
411 representation for a device node can be used, where applicable.
412
413 **/
414 VOID
DevPathToTextAcpiEx(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)415 DevPathToTextAcpiEx (
416 IN OUT POOL_PRINT *Str,
417 IN VOID *DevPath,
418 IN BOOLEAN DisplayOnly,
419 IN BOOLEAN AllowShortcuts
420 )
421 {
422 ACPI_EXTENDED_HID_DEVICE_PATH *AcpiEx;
423 CHAR8 *HIDStr;
424 CHAR8 *UIDStr;
425 CHAR8 *CIDStr;
426 CHAR16 HIDText[11];
427 CHAR16 CIDText[11];
428
429 AcpiEx = DevPath;
430 HIDStr = (CHAR8 *) (((UINT8 *) AcpiEx) + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
431 UIDStr = HIDStr + AsciiStrLen (HIDStr) + 1;
432 CIDStr = UIDStr + AsciiStrLen (UIDStr) + 1;
433
434 //
435 // Converts EISA identification to string.
436 //
437 UnicodeSPrint (
438 HIDText,
439 sizeof (HIDText),
440 L"%c%c%c%04X",
441 ((AcpiEx->HID >> 10) & 0x1f) + 'A' - 1,
442 ((AcpiEx->HID >> 5) & 0x1f) + 'A' - 1,
443 ((AcpiEx->HID >> 0) & 0x1f) + 'A' - 1,
444 (AcpiEx->HID >> 16) & 0xFFFF
445 );
446 UnicodeSPrint (
447 CIDText,
448 sizeof (CIDText),
449 L"%c%c%c%04X",
450 ((AcpiEx->CID >> 10) & 0x1f) + 'A' - 1,
451 ((AcpiEx->CID >> 5) & 0x1f) + 'A' - 1,
452 ((AcpiEx->CID >> 0) & 0x1f) + 'A' - 1,
453 (AcpiEx->CID >> 16) & 0xFFFF
454 );
455
456 if ((*HIDStr == '\0') && (*CIDStr == '\0') && (AcpiEx->UID == 0)) {
457 //
458 // use AcpiExp()
459 //
460 UefiDevicePathLibCatPrint (
461 Str,
462 L"AcpiExp(%s,%s,%a)",
463 HIDText,
464 CIDText,
465 UIDStr
466 );
467 } else {
468 if (AllowShortcuts) {
469 //
470 // display only
471 //
472 if (AcpiEx->HID == 0) {
473 UefiDevicePathLibCatPrint (Str, L"AcpiEx(%a,", HIDStr);
474 } else {
475 UefiDevicePathLibCatPrint (Str, L"AcpiEx(%s,", HIDText);
476 }
477
478 if (AcpiEx->UID == 0) {
479 UefiDevicePathLibCatPrint (Str, L"%a,", UIDStr);
480 } else {
481 UefiDevicePathLibCatPrint (Str, L"0x%x,", AcpiEx->UID);
482 }
483
484 if (AcpiEx->CID == 0) {
485 UefiDevicePathLibCatPrint (Str, L"%a)", CIDStr);
486 } else {
487 UefiDevicePathLibCatPrint (Str, L"%s)", CIDText);
488 }
489 } else {
490 UefiDevicePathLibCatPrint (
491 Str,
492 L"AcpiEx(%s,%s,0x%x,%a,%a,%a)",
493 HIDText,
494 CIDText,
495 AcpiEx->UID,
496 HIDStr,
497 CIDStr,
498 UIDStr
499 );
500 }
501 }
502 }
503
504 /**
505 Converts a ACPI address device path structure to its string representative.
506
507 @param Str The string representative of input device.
508 @param DevPath The input device path structure.
509 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
510 of the display node is used, where applicable. If DisplayOnly
511 is FALSE, then the longer text representation of the display node
512 is used.
513 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
514 representation for a device node can be used, where applicable.
515
516 **/
517 VOID
DevPathToTextAcpiAdr(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)518 DevPathToTextAcpiAdr (
519 IN OUT POOL_PRINT *Str,
520 IN VOID *DevPath,
521 IN BOOLEAN DisplayOnly,
522 IN BOOLEAN AllowShortcuts
523 )
524 {
525 ACPI_ADR_DEVICE_PATH *AcpiAdr;
526 UINT16 Index;
527 UINT16 Length;
528 UINT16 AdditionalAdrCount;
529
530 AcpiAdr = DevPath;
531 Length = (UINT16) DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) AcpiAdr);
532 AdditionalAdrCount = (UINT16) ((Length - 8) / 4);
533
534 UefiDevicePathLibCatPrint (Str, L"AcpiAdr(0x%x", AcpiAdr->ADR);
535 for (Index = 0; Index < AdditionalAdrCount; Index++) {
536 UefiDevicePathLibCatPrint (Str, L",0x%x", *(UINT32 *) ((UINT8 *) AcpiAdr + 8 + Index * 4));
537 }
538 UefiDevicePathLibCatPrint (Str, L")");
539 }
540
541 /**
542 Converts a ATAPI device path structure to its string representative.
543
544 @param Str The string representative of input device.
545 @param DevPath The input device path structure.
546 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
547 of the display node is used, where applicable. If DisplayOnly
548 is FALSE, then the longer text representation of the display node
549 is used.
550 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
551 representation for a device node can be used, where applicable.
552
553 **/
554 VOID
DevPathToTextAtapi(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)555 DevPathToTextAtapi (
556 IN OUT POOL_PRINT *Str,
557 IN VOID *DevPath,
558 IN BOOLEAN DisplayOnly,
559 IN BOOLEAN AllowShortcuts
560 )
561 {
562 ATAPI_DEVICE_PATH *Atapi;
563
564 Atapi = DevPath;
565
566 if (DisplayOnly) {
567 UefiDevicePathLibCatPrint (Str, L"Ata(0x%x)", Atapi->Lun);
568 } else {
569 UefiDevicePathLibCatPrint (
570 Str,
571 L"Ata(%s,%s,0x%x)",
572 (Atapi->PrimarySecondary == 1) ? L"Secondary" : L"Primary",
573 (Atapi->SlaveMaster == 1) ? L"Slave" : L"Master",
574 Atapi->Lun
575 );
576 }
577 }
578
579 /**
580 Converts a SCSI device path structure to its string representative.
581
582 @param Str The string representative of input device.
583 @param DevPath The input device path structure.
584 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
585 of the display node is used, where applicable. If DisplayOnly
586 is FALSE, then the longer text representation of the display node
587 is used.
588 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
589 representation for a device node can be used, where applicable.
590
591 **/
592 VOID
DevPathToTextScsi(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)593 DevPathToTextScsi (
594 IN OUT POOL_PRINT *Str,
595 IN VOID *DevPath,
596 IN BOOLEAN DisplayOnly,
597 IN BOOLEAN AllowShortcuts
598 )
599 {
600 SCSI_DEVICE_PATH *Scsi;
601
602 Scsi = DevPath;
603 UefiDevicePathLibCatPrint (Str, L"Scsi(0x%x,0x%x)", Scsi->Pun, Scsi->Lun);
604 }
605
606 /**
607 Converts a Fibre device path structure to its string representative.
608
609 @param Str The string representative of input device.
610 @param DevPath The input device path structure.
611 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
612 of the display node is used, where applicable. If DisplayOnly
613 is FALSE, then the longer text representation of the display node
614 is used.
615 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
616 representation for a device node can be used, where applicable.
617
618 **/
619 VOID
DevPathToTextFibre(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)620 DevPathToTextFibre (
621 IN OUT POOL_PRINT *Str,
622 IN VOID *DevPath,
623 IN BOOLEAN DisplayOnly,
624 IN BOOLEAN AllowShortcuts
625 )
626 {
627 FIBRECHANNEL_DEVICE_PATH *Fibre;
628
629 Fibre = DevPath;
630 UefiDevicePathLibCatPrint (Str, L"Fibre(0x%lx,0x%lx)", Fibre->WWN, Fibre->Lun);
631 }
632
633 /**
634 Converts a FibreEx device path structure to its string representative.
635
636 @param Str The string representative of input device.
637 @param DevPath The input device path structure.
638 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
639 of the display node is used, where applicable. If DisplayOnly
640 is FALSE, then the longer text representation of the display node
641 is used.
642 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
643 representation for a device node can be used, where applicable.
644
645 **/
646 VOID
DevPathToTextFibreEx(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)647 DevPathToTextFibreEx (
648 IN OUT POOL_PRINT *Str,
649 IN VOID *DevPath,
650 IN BOOLEAN DisplayOnly,
651 IN BOOLEAN AllowShortcuts
652 )
653 {
654 FIBRECHANNELEX_DEVICE_PATH *FibreEx;
655 UINTN Index;
656
657 FibreEx = DevPath;
658 UefiDevicePathLibCatPrint (Str, L"FibreEx(0x");
659 for (Index = 0; Index < sizeof (FibreEx->WWN) / sizeof (FibreEx->WWN[0]); Index++) {
660 UefiDevicePathLibCatPrint (Str, L"%02x", FibreEx->WWN[Index]);
661 }
662 UefiDevicePathLibCatPrint (Str, L",0x");
663 for (Index = 0; Index < sizeof (FibreEx->Lun) / sizeof (FibreEx->Lun[0]); Index++) {
664 UefiDevicePathLibCatPrint (Str, L"%02x", FibreEx->Lun[Index]);
665 }
666 UefiDevicePathLibCatPrint (Str, L")");
667 }
668
669 /**
670 Converts a Sas Ex device path structure to its string representative.
671
672 @param Str The string representative of input device.
673 @param DevPath The input device path structure.
674 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
675 of the display node is used, where applicable. If DisplayOnly
676 is FALSE, then the longer text representation of the display node
677 is used.
678 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
679 representation for a device node can be used, where applicable.
680
681 **/
682 VOID
DevPathToTextSasEx(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)683 DevPathToTextSasEx (
684 IN OUT POOL_PRINT *Str,
685 IN VOID *DevPath,
686 IN BOOLEAN DisplayOnly,
687 IN BOOLEAN AllowShortcuts
688 )
689 {
690 SASEX_DEVICE_PATH *SasEx;
691 UINTN Index;
692
693 SasEx = DevPath;
694 UefiDevicePathLibCatPrint (Str, L"SasEx(0x");
695
696 for (Index = 0; Index < sizeof (SasEx->SasAddress) / sizeof (SasEx->SasAddress[0]); Index++) {
697 UefiDevicePathLibCatPrint (Str, L"%02x", SasEx->SasAddress[Index]);
698 }
699 UefiDevicePathLibCatPrint (Str, L",0x");
700 for (Index = 0; Index < sizeof (SasEx->Lun) / sizeof (SasEx->Lun[0]); Index++) {
701 UefiDevicePathLibCatPrint (Str, L"%02x", SasEx->Lun[Index]);
702 }
703 UefiDevicePathLibCatPrint (Str, L",0x%x,", SasEx->RelativeTargetPort);
704
705 if (((SasEx->DeviceTopology & 0x0f) == 0) && ((SasEx->DeviceTopology & BIT7) == 0)) {
706 UefiDevicePathLibCatPrint (Str, L"NoTopology,0,0,0");
707 } else if (((SasEx->DeviceTopology & 0x0f) <= 2) && ((SasEx->DeviceTopology & BIT7) == 0)) {
708 UefiDevicePathLibCatPrint (
709 Str,
710 L"%s,%s,%s,",
711 ((SasEx->DeviceTopology & BIT4) != 0) ? L"SATA" : L"SAS",
712 ((SasEx->DeviceTopology & BIT5) != 0) ? L"External" : L"Internal",
713 ((SasEx->DeviceTopology & BIT6) != 0) ? L"Expanded" : L"Direct"
714 );
715 if ((SasEx->DeviceTopology & 0x0f) == 1) {
716 UefiDevicePathLibCatPrint (Str, L"0");
717 } else {
718 //
719 // Value 0x0 thru 0xFF -> Drive 1 thru Drive 256
720 //
721 UefiDevicePathLibCatPrint (Str, L"0x%x", ((SasEx->DeviceTopology >> 8) & 0xff) + 1);
722 }
723 } else {
724 UefiDevicePathLibCatPrint (Str, L"0x%x,0,0,0", SasEx->DeviceTopology);
725 }
726
727 UefiDevicePathLibCatPrint (Str, L")");
728 return ;
729
730 }
731
732 /**
733 Converts a NVM Express Namespace device path structure to its string representative.
734
735 @param Str The string representative of input device.
736 @param DevPath The input device path structure.
737 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
738 of the display node is used, where applicable. If DisplayOnly
739 is FALSE, then the longer text representation of the display node
740 is used.
741 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
742 representation for a device node can be used, where applicable.
743
744 **/
745 VOID
DevPathToTextNVMe(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)746 DevPathToTextNVMe (
747 IN OUT POOL_PRINT *Str,
748 IN VOID *DevPath,
749 IN BOOLEAN DisplayOnly,
750 IN BOOLEAN AllowShortcuts
751 )
752 {
753 NVME_NAMESPACE_DEVICE_PATH *Nvme;
754 UINT8 *Uuid;
755
756 Nvme = DevPath;
757 Uuid = (UINT8 *) &Nvme->NamespaceUuid;
758 UefiDevicePathLibCatPrint (
759 Str,
760 L"NVMe(0x%x,%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x)",
761 Nvme->NamespaceId,
762 Uuid[7], Uuid[6], Uuid[5], Uuid[4],
763 Uuid[3], Uuid[2], Uuid[1], Uuid[0]
764 );
765 }
766
767 /**
768 Converts a UFS device path structure to its string representative.
769
770 @param Str The string representative of input device.
771 @param DevPath The input device path structure.
772 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
773 of the display node is used, where applicable. If DisplayOnly
774 is FALSE, then the longer text representation of the display node
775 is used.
776 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
777 representation for a device node can be used, where applicable.
778
779 **/
780 VOID
DevPathToTextUfs(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)781 DevPathToTextUfs (
782 IN OUT POOL_PRINT *Str,
783 IN VOID *DevPath,
784 IN BOOLEAN DisplayOnly,
785 IN BOOLEAN AllowShortcuts
786 )
787 {
788 UFS_DEVICE_PATH *Ufs;
789
790 Ufs = DevPath;
791 UefiDevicePathLibCatPrint (Str, L"UFS(0x%x,0x%x)", Ufs->Pun, Ufs->Lun);
792 }
793
794 /**
795 Converts a SD (Secure Digital) device path structure to its string representative.
796
797 @param Str The string representative of input device.
798 @param DevPath The input device path structure.
799 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
800 of the display node is used, where applicable. If DisplayOnly
801 is FALSE, then the longer text representation of the display node
802 is used.
803 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
804 representation for a device node can be used, where applicable.
805
806 **/
807 VOID
DevPathToTextSd(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)808 DevPathToTextSd (
809 IN OUT POOL_PRINT *Str,
810 IN VOID *DevPath,
811 IN BOOLEAN DisplayOnly,
812 IN BOOLEAN AllowShortcuts
813 )
814 {
815 SD_DEVICE_PATH *Sd;
816
817 Sd = DevPath;
818 UefiDevicePathLibCatPrint (
819 Str,
820 L"SD(0x%x)",
821 Sd->SlotNumber
822 );
823 }
824
825 /**
826 Converts a 1394 device path structure to its string representative.
827
828 @param Str The string representative of input device.
829 @param DevPath The input device path structure.
830 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
831 of the display node is used, where applicable. If DisplayOnly
832 is FALSE, then the longer text representation of the display node
833 is used.
834 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
835 representation for a device node can be used, where applicable.
836
837 **/
838 VOID
DevPathToText1394(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)839 DevPathToText1394 (
840 IN OUT POOL_PRINT *Str,
841 IN VOID *DevPath,
842 IN BOOLEAN DisplayOnly,
843 IN BOOLEAN AllowShortcuts
844 )
845 {
846 F1394_DEVICE_PATH *F1394DevPath;
847
848 F1394DevPath = DevPath;
849 //
850 // Guid has format of IEEE-EUI64
851 //
852 UefiDevicePathLibCatPrint (Str, L"I1394(%016lx)", F1394DevPath->Guid);
853 }
854
855 /**
856 Converts a USB device path structure to its string representative.
857
858 @param Str The string representative of input device.
859 @param DevPath The input device path structure.
860 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
861 of the display node is used, where applicable. If DisplayOnly
862 is FALSE, then the longer text representation of the display node
863 is used.
864 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
865 representation for a device node can be used, where applicable.
866
867 **/
868 VOID
DevPathToTextUsb(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)869 DevPathToTextUsb (
870 IN OUT POOL_PRINT *Str,
871 IN VOID *DevPath,
872 IN BOOLEAN DisplayOnly,
873 IN BOOLEAN AllowShortcuts
874 )
875 {
876 USB_DEVICE_PATH *Usb;
877
878 Usb = DevPath;
879 UefiDevicePathLibCatPrint (Str, L"USB(0x%x,0x%x)", Usb->ParentPortNumber, Usb->InterfaceNumber);
880 }
881
882 /**
883 Converts a USB WWID device path structure to its string representative.
884
885 @param Str The string representative of input device.
886 @param DevPath The input device path structure.
887 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
888 of the display node is used, where applicable. If DisplayOnly
889 is FALSE, then the longer text representation of the display node
890 is used.
891 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
892 representation for a device node can be used, where applicable.
893
894 **/
895 VOID
DevPathToTextUsbWWID(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)896 DevPathToTextUsbWWID (
897 IN OUT POOL_PRINT *Str,
898 IN VOID *DevPath,
899 IN BOOLEAN DisplayOnly,
900 IN BOOLEAN AllowShortcuts
901 )
902 {
903 USB_WWID_DEVICE_PATH *UsbWWId;
904 CHAR16 *SerialNumberStr;
905 CHAR16 *NewStr;
906 UINT16 Length;
907
908 UsbWWId = DevPath;
909
910 SerialNumberStr = (CHAR16 *) ((UINT8 *) UsbWWId + sizeof (USB_WWID_DEVICE_PATH));
911 Length = (UINT16) ((DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) UsbWWId) - sizeof (USB_WWID_DEVICE_PATH)) / sizeof (CHAR16));
912 if (SerialNumberStr [Length - 1] != 0) {
913 //
914 // In case no NULL terminator in SerialNumber, create a new one with NULL terminator
915 //
916 NewStr = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), SerialNumberStr);
917 ASSERT (NewStr != NULL);
918 NewStr [Length] = 0;
919 SerialNumberStr = NewStr;
920 }
921
922 UefiDevicePathLibCatPrint (
923 Str,
924 L"UsbWwid(0x%x,0x%x,0x%x,\"%s\")",
925 UsbWWId->VendorId,
926 UsbWWId->ProductId,
927 UsbWWId->InterfaceNumber,
928 SerialNumberStr
929 );
930 }
931
932 /**
933 Converts a Logic Unit device path structure to its string representative.
934
935 @param Str The string representative of input device.
936 @param DevPath The input device path structure.
937 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
938 of the display node is used, where applicable. If DisplayOnly
939 is FALSE, then the longer text representation of the display node
940 is used.
941 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
942 representation for a device node can be used, where applicable.
943
944 **/
945 VOID
DevPathToTextLogicalUnit(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)946 DevPathToTextLogicalUnit (
947 IN OUT POOL_PRINT *Str,
948 IN VOID *DevPath,
949 IN BOOLEAN DisplayOnly,
950 IN BOOLEAN AllowShortcuts
951 )
952 {
953 DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;
954
955 LogicalUnit = DevPath;
956 UefiDevicePathLibCatPrint (Str, L"Unit(0x%x)", LogicalUnit->Lun);
957 }
958
959 /**
960 Converts a USB class device path structure to its string representative.
961
962 @param Str The string representative of input device.
963 @param DevPath The input device path structure.
964 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
965 of the display node is used, where applicable. If DisplayOnly
966 is FALSE, then the longer text representation of the display node
967 is used.
968 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
969 representation for a device node can be used, where applicable.
970
971 **/
972 VOID
DevPathToTextUsbClass(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)973 DevPathToTextUsbClass (
974 IN OUT POOL_PRINT *Str,
975 IN VOID *DevPath,
976 IN BOOLEAN DisplayOnly,
977 IN BOOLEAN AllowShortcuts
978 )
979 {
980 USB_CLASS_DEVICE_PATH *UsbClass;
981 BOOLEAN IsKnownSubClass;
982
983
984 UsbClass = DevPath;
985
986 IsKnownSubClass = TRUE;
987 switch (UsbClass->DeviceClass) {
988 case USB_CLASS_AUDIO:
989 UefiDevicePathLibCatPrint (Str, L"UsbAudio");
990 break;
991
992 case USB_CLASS_CDCCONTROL:
993 UefiDevicePathLibCatPrint (Str, L"UsbCDCControl");
994 break;
995
996 case USB_CLASS_HID:
997 UefiDevicePathLibCatPrint (Str, L"UsbHID");
998 break;
999
1000 case USB_CLASS_IMAGE:
1001 UefiDevicePathLibCatPrint (Str, L"UsbImage");
1002 break;
1003
1004 case USB_CLASS_PRINTER:
1005 UefiDevicePathLibCatPrint (Str, L"UsbPrinter");
1006 break;
1007
1008 case USB_CLASS_MASS_STORAGE:
1009 UefiDevicePathLibCatPrint (Str, L"UsbMassStorage");
1010 break;
1011
1012 case USB_CLASS_HUB:
1013 UefiDevicePathLibCatPrint (Str, L"UsbHub");
1014 break;
1015
1016 case USB_CLASS_CDCDATA:
1017 UefiDevicePathLibCatPrint (Str, L"UsbCDCData");
1018 break;
1019
1020 case USB_CLASS_SMART_CARD:
1021 UefiDevicePathLibCatPrint (Str, L"UsbSmartCard");
1022 break;
1023
1024 case USB_CLASS_VIDEO:
1025 UefiDevicePathLibCatPrint (Str, L"UsbVideo");
1026 break;
1027
1028 case USB_CLASS_DIAGNOSTIC:
1029 UefiDevicePathLibCatPrint (Str, L"UsbDiagnostic");
1030 break;
1031
1032 case USB_CLASS_WIRELESS:
1033 UefiDevicePathLibCatPrint (Str, L"UsbWireless");
1034 break;
1035
1036 default:
1037 IsKnownSubClass = FALSE;
1038 break;
1039 }
1040
1041 if (IsKnownSubClass) {
1042 UefiDevicePathLibCatPrint (
1043 Str,
1044 L"(0x%x,0x%x,0x%x,0x%x)",
1045 UsbClass->VendorId,
1046 UsbClass->ProductId,
1047 UsbClass->DeviceSubClass,
1048 UsbClass->DeviceProtocol
1049 );
1050 return;
1051 }
1052
1053 if (UsbClass->DeviceClass == USB_CLASS_RESERVE) {
1054 if (UsbClass->DeviceSubClass == USB_SUBCLASS_FW_UPDATE) {
1055 UefiDevicePathLibCatPrint (
1056 Str,
1057 L"UsbDeviceFirmwareUpdate(0x%x,0x%x,0x%x)",
1058 UsbClass->VendorId,
1059 UsbClass->ProductId,
1060 UsbClass->DeviceProtocol
1061 );
1062 return;
1063 } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_IRDA_BRIDGE) {
1064 UefiDevicePathLibCatPrint (
1065 Str,
1066 L"UsbIrdaBridge(0x%x,0x%x,0x%x)",
1067 UsbClass->VendorId,
1068 UsbClass->ProductId,
1069 UsbClass->DeviceProtocol
1070 );
1071 return;
1072 } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_TEST) {
1073 UefiDevicePathLibCatPrint (
1074 Str,
1075 L"UsbTestAndMeasurement(0x%x,0x%x,0x%x)",
1076 UsbClass->VendorId,
1077 UsbClass->ProductId,
1078 UsbClass->DeviceProtocol
1079 );
1080 return;
1081 }
1082 }
1083
1084 UefiDevicePathLibCatPrint (
1085 Str,
1086 L"UsbClass(0x%x,0x%x,0x%x,0x%x,0x%x)",
1087 UsbClass->VendorId,
1088 UsbClass->ProductId,
1089 UsbClass->DeviceClass,
1090 UsbClass->DeviceSubClass,
1091 UsbClass->DeviceProtocol
1092 );
1093 }
1094
1095 /**
1096 Converts a SATA device path structure to its string representative.
1097
1098 @param Str The string representative of input device.
1099 @param DevPath The input device path structure.
1100 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1101 of the display node is used, where applicable. If DisplayOnly
1102 is FALSE, then the longer text representation of the display node
1103 is used.
1104 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1105 representation for a device node can be used, where applicable.
1106
1107 **/
1108 VOID
DevPathToTextSata(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1109 DevPathToTextSata (
1110 IN OUT POOL_PRINT *Str,
1111 IN VOID *DevPath,
1112 IN BOOLEAN DisplayOnly,
1113 IN BOOLEAN AllowShortcuts
1114 )
1115 {
1116 SATA_DEVICE_PATH *Sata;
1117
1118 Sata = DevPath;
1119 UefiDevicePathLibCatPrint (
1120 Str,
1121 L"Sata(0x%x,0x%x,0x%x)",
1122 Sata->HBAPortNumber,
1123 Sata->PortMultiplierPortNumber,
1124 Sata->Lun
1125 );
1126 }
1127
1128 /**
1129 Converts a I20 device path structure to its string representative.
1130
1131 @param Str The string representative of input device.
1132 @param DevPath The input device path structure.
1133 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1134 of the display node is used, where applicable. If DisplayOnly
1135 is FALSE, then the longer text representation of the display node
1136 is used.
1137 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1138 representation for a device node can be used, where applicable.
1139
1140 **/
1141 VOID
DevPathToTextI2O(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1142 DevPathToTextI2O (
1143 IN OUT POOL_PRINT *Str,
1144 IN VOID *DevPath,
1145 IN BOOLEAN DisplayOnly,
1146 IN BOOLEAN AllowShortcuts
1147 )
1148 {
1149 I2O_DEVICE_PATH *I2ODevPath;
1150
1151 I2ODevPath = DevPath;
1152 UefiDevicePathLibCatPrint (Str, L"I2O(0x%x)", I2ODevPath->Tid);
1153 }
1154
1155 /**
1156 Converts a MAC address device path structure to its string representative.
1157
1158 @param Str The string representative of input device.
1159 @param DevPath The input device path structure.
1160 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1161 of the display node is used, where applicable. If DisplayOnly
1162 is FALSE, then the longer text representation of the display node
1163 is used.
1164 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1165 representation for a device node can be used, where applicable.
1166
1167 **/
1168 VOID
DevPathToTextMacAddr(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1169 DevPathToTextMacAddr (
1170 IN OUT POOL_PRINT *Str,
1171 IN VOID *DevPath,
1172 IN BOOLEAN DisplayOnly,
1173 IN BOOLEAN AllowShortcuts
1174 )
1175 {
1176 MAC_ADDR_DEVICE_PATH *MacDevPath;
1177 UINTN HwAddressSize;
1178 UINTN Index;
1179
1180 MacDevPath = DevPath;
1181
1182 HwAddressSize = sizeof (EFI_MAC_ADDRESS);
1183 if (MacDevPath->IfType == 0x01 || MacDevPath->IfType == 0x00) {
1184 HwAddressSize = 6;
1185 }
1186
1187 UefiDevicePathLibCatPrint (Str, L"MAC(");
1188
1189 for (Index = 0; Index < HwAddressSize; Index++) {
1190 UefiDevicePathLibCatPrint (Str, L"%02x", MacDevPath->MacAddress.Addr[Index]);
1191 }
1192
1193 UefiDevicePathLibCatPrint (Str, L",0x%x)", MacDevPath->IfType);
1194 }
1195
1196 /**
1197 Converts network protocol string to its text representation.
1198
1199 @param Str The string representative of input device.
1200 @param Protocol The network protocol ID.
1201
1202 **/
1203 VOID
CatNetworkProtocol(IN OUT POOL_PRINT * Str,IN UINT16 Protocol)1204 CatNetworkProtocol (
1205 IN OUT POOL_PRINT *Str,
1206 IN UINT16 Protocol
1207 )
1208 {
1209 if (Protocol == RFC_1700_TCP_PROTOCOL) {
1210 UefiDevicePathLibCatPrint (Str, L"TCP");
1211 } else if (Protocol == RFC_1700_UDP_PROTOCOL) {
1212 UefiDevicePathLibCatPrint (Str, L"UDP");
1213 } else {
1214 UefiDevicePathLibCatPrint (Str, L"0x%x", Protocol);
1215 }
1216 }
1217
1218 /**
1219 Converts IP v4 address to its text representation.
1220
1221 @param Str The string representative of input device.
1222 @param Address The IP v4 address.
1223 **/
1224 VOID
CatIPv4Address(IN OUT POOL_PRINT * Str,IN EFI_IPv4_ADDRESS * Address)1225 CatIPv4Address (
1226 IN OUT POOL_PRINT *Str,
1227 IN EFI_IPv4_ADDRESS *Address
1228 )
1229 {
1230 UefiDevicePathLibCatPrint (Str, L"%d.%d.%d.%d", Address->Addr[0], Address->Addr[1], Address->Addr[2], Address->Addr[3]);
1231 }
1232
1233 /**
1234 Converts IP v6 address to its text representation.
1235
1236 @param Str The string representative of input device.
1237 @param Address The IP v6 address.
1238 **/
1239 VOID
CatIPv6Address(IN OUT POOL_PRINT * Str,IN EFI_IPv6_ADDRESS * Address)1240 CatIPv6Address (
1241 IN OUT POOL_PRINT *Str,
1242 IN EFI_IPv6_ADDRESS *Address
1243 )
1244 {
1245 UefiDevicePathLibCatPrint (
1246 Str, L"%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x",
1247 Address->Addr[0], Address->Addr[1],
1248 Address->Addr[2], Address->Addr[3],
1249 Address->Addr[4], Address->Addr[5],
1250 Address->Addr[6], Address->Addr[7],
1251 Address->Addr[8], Address->Addr[9],
1252 Address->Addr[10], Address->Addr[11],
1253 Address->Addr[12], Address->Addr[13],
1254 Address->Addr[14], Address->Addr[15]
1255 );
1256 }
1257
1258 /**
1259 Converts a IPv4 device path structure to its string representative.
1260
1261 @param Str The string representative of input device.
1262 @param DevPath The input device path structure.
1263 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1264 of the display node is used, where applicable. If DisplayOnly
1265 is FALSE, then the longer text representation of the display node
1266 is used.
1267 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1268 representation for a device node can be used, where applicable.
1269
1270 **/
1271 VOID
DevPathToTextIPv4(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1272 DevPathToTextIPv4 (
1273 IN OUT POOL_PRINT *Str,
1274 IN VOID *DevPath,
1275 IN BOOLEAN DisplayOnly,
1276 IN BOOLEAN AllowShortcuts
1277 )
1278 {
1279 IPv4_DEVICE_PATH *IPDevPath;
1280
1281 IPDevPath = DevPath;
1282 UefiDevicePathLibCatPrint (Str, L"IPv4(");
1283 CatIPv4Address (Str, &IPDevPath->RemoteIpAddress);
1284
1285 if (DisplayOnly) {
1286 UefiDevicePathLibCatPrint (Str, L")");
1287 return ;
1288 }
1289
1290 UefiDevicePathLibCatPrint (Str, L",");
1291 CatNetworkProtocol (Str, IPDevPath->Protocol);
1292
1293 UefiDevicePathLibCatPrint (Str, L",%s,", IPDevPath->StaticIpAddress ? L"Static" : L"DHCP");
1294 CatIPv4Address (Str, &IPDevPath->LocalIpAddress);
1295 if (DevicePathNodeLength (IPDevPath) == sizeof (IPv4_DEVICE_PATH)) {
1296 UefiDevicePathLibCatPrint (Str, L",");
1297 CatIPv4Address (Str, &IPDevPath->GatewayIpAddress);
1298 UefiDevicePathLibCatPrint (Str, L",");
1299 CatIPv4Address (Str, &IPDevPath->SubnetMask);
1300 }
1301 UefiDevicePathLibCatPrint (Str, L")");
1302 }
1303
1304 /**
1305 Converts a IPv6 device path structure to its string representative.
1306
1307 @param Str The string representative of input device.
1308 @param DevPath The input device path structure.
1309 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1310 of the display node is used, where applicable. If DisplayOnly
1311 is FALSE, then the longer text representation of the display node
1312 is used.
1313 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1314 representation for a device node can be used, where applicable.
1315
1316 **/
1317 VOID
DevPathToTextIPv6(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1318 DevPathToTextIPv6 (
1319 IN OUT POOL_PRINT *Str,
1320 IN VOID *DevPath,
1321 IN BOOLEAN DisplayOnly,
1322 IN BOOLEAN AllowShortcuts
1323 )
1324 {
1325 IPv6_DEVICE_PATH *IPDevPath;
1326
1327 IPDevPath = DevPath;
1328 UefiDevicePathLibCatPrint (Str, L"IPv6(");
1329 CatIPv6Address (Str, &IPDevPath->RemoteIpAddress);
1330 if (DisplayOnly) {
1331 UefiDevicePathLibCatPrint (Str, L")");
1332 return ;
1333 }
1334
1335 UefiDevicePathLibCatPrint (Str, L",");
1336 CatNetworkProtocol (Str, IPDevPath->Protocol);
1337
1338 switch (IPDevPath->IpAddressOrigin) {
1339 case 0:
1340 UefiDevicePathLibCatPrint (Str, L",Static,");
1341 break;
1342 case 1:
1343 UefiDevicePathLibCatPrint (Str, L",StatelessAutoConfigure,");
1344 break;
1345 default:
1346 UefiDevicePathLibCatPrint (Str, L",StatefulAutoConfigure,");
1347 break;
1348 }
1349
1350 CatIPv6Address (Str, &IPDevPath->LocalIpAddress);
1351
1352 if (DevicePathNodeLength (IPDevPath) == sizeof (IPv6_DEVICE_PATH)) {
1353 UefiDevicePathLibCatPrint (Str, L",0x%x,", IPDevPath->PrefixLength);
1354 CatIPv6Address (Str, &IPDevPath->GatewayIpAddress);
1355 }
1356 UefiDevicePathLibCatPrint (Str, L")");
1357 }
1358
1359 /**
1360 Converts an Infini Band device path structure to its string representative.
1361
1362 @param Str The string representative of input device.
1363 @param DevPath The input device path structure.
1364 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1365 of the display node is used, where applicable. If DisplayOnly
1366 is FALSE, then the longer text representation of the display node
1367 is used.
1368 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1369 representation for a device node can be used, where applicable.
1370
1371 **/
1372 VOID
DevPathToTextInfiniBand(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1373 DevPathToTextInfiniBand (
1374 IN OUT POOL_PRINT *Str,
1375 IN VOID *DevPath,
1376 IN BOOLEAN DisplayOnly,
1377 IN BOOLEAN AllowShortcuts
1378 )
1379 {
1380 INFINIBAND_DEVICE_PATH *InfiniBand;
1381
1382 InfiniBand = DevPath;
1383 UefiDevicePathLibCatPrint (
1384 Str,
1385 L"Infiniband(0x%x,%g,0x%lx,0x%lx,0x%lx)",
1386 InfiniBand->ResourceFlags,
1387 InfiniBand->PortGid,
1388 InfiniBand->ServiceId,
1389 InfiniBand->TargetPortId,
1390 InfiniBand->DeviceId
1391 );
1392 }
1393
1394 /**
1395 Converts a UART device path structure to its string representative.
1396
1397 @param Str The string representative of input device.
1398 @param DevPath The input device path structure.
1399 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1400 of the display node is used, where applicable. If DisplayOnly
1401 is FALSE, then the longer text representation of the display node
1402 is used.
1403 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1404 representation for a device node can be used, where applicable.
1405
1406 **/
1407 VOID
DevPathToTextUart(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1408 DevPathToTextUart (
1409 IN OUT POOL_PRINT *Str,
1410 IN VOID *DevPath,
1411 IN BOOLEAN DisplayOnly,
1412 IN BOOLEAN AllowShortcuts
1413 )
1414 {
1415 UART_DEVICE_PATH *Uart;
1416 CHAR8 Parity;
1417
1418 Uart = DevPath;
1419 switch (Uart->Parity) {
1420 case 0:
1421 Parity = 'D';
1422 break;
1423
1424 case 1:
1425 Parity = 'N';
1426 break;
1427
1428 case 2:
1429 Parity = 'E';
1430 break;
1431
1432 case 3:
1433 Parity = 'O';
1434 break;
1435
1436 case 4:
1437 Parity = 'M';
1438 break;
1439
1440 case 5:
1441 Parity = 'S';
1442 break;
1443
1444 default:
1445 Parity = 'x';
1446 break;
1447 }
1448
1449 if (Uart->BaudRate == 0) {
1450 UefiDevicePathLibCatPrint (Str, L"Uart(DEFAULT,");
1451 } else {
1452 UefiDevicePathLibCatPrint (Str, L"Uart(%ld,", Uart->BaudRate);
1453 }
1454
1455 if (Uart->DataBits == 0) {
1456 UefiDevicePathLibCatPrint (Str, L"DEFAULT,");
1457 } else {
1458 UefiDevicePathLibCatPrint (Str, L"%d,", Uart->DataBits);
1459 }
1460
1461 UefiDevicePathLibCatPrint (Str, L"%c,", Parity);
1462
1463 switch (Uart->StopBits) {
1464 case 0:
1465 UefiDevicePathLibCatPrint (Str, L"D)");
1466 break;
1467
1468 case 1:
1469 UefiDevicePathLibCatPrint (Str, L"1)");
1470 break;
1471
1472 case 2:
1473 UefiDevicePathLibCatPrint (Str, L"1.5)");
1474 break;
1475
1476 case 3:
1477 UefiDevicePathLibCatPrint (Str, L"2)");
1478 break;
1479
1480 default:
1481 UefiDevicePathLibCatPrint (Str, L"x)");
1482 break;
1483 }
1484 }
1485
1486 /**
1487 Converts an iSCSI device path structure to its string representative.
1488
1489 @param Str The string representative of input device.
1490 @param DevPath The input device path structure.
1491 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1492 of the display node is used, where applicable. If DisplayOnly
1493 is FALSE, then the longer text representation of the display node
1494 is used.
1495 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1496 representation for a device node can be used, where applicable.
1497
1498 **/
1499 VOID
DevPathToTextiSCSI(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1500 DevPathToTextiSCSI (
1501 IN OUT POOL_PRINT *Str,
1502 IN VOID *DevPath,
1503 IN BOOLEAN DisplayOnly,
1504 IN BOOLEAN AllowShortcuts
1505 )
1506 {
1507 ISCSI_DEVICE_PATH_WITH_NAME *ISCSIDevPath;
1508 UINT16 Options;
1509
1510 ISCSIDevPath = DevPath;
1511 UefiDevicePathLibCatPrint (
1512 Str,
1513 L"iSCSI(%a,0x%x,0x%lx,",
1514 ISCSIDevPath->TargetName,
1515 ISCSIDevPath->TargetPortalGroupTag,
1516 ISCSIDevPath->Lun
1517 );
1518
1519 Options = ISCSIDevPath->LoginOption;
1520 UefiDevicePathLibCatPrint (Str, L"%s,", (((Options >> 1) & 0x0001) != 0) ? L"CRC32C" : L"None");
1521 UefiDevicePathLibCatPrint (Str, L"%s,", (((Options >> 3) & 0x0001) != 0) ? L"CRC32C" : L"None");
1522 if (((Options >> 11) & 0x0001) != 0) {
1523 UefiDevicePathLibCatPrint (Str, L"%s,", L"None");
1524 } else if (((Options >> 12) & 0x0001) != 0) {
1525 UefiDevicePathLibCatPrint (Str, L"%s,", L"CHAP_UNI");
1526 } else {
1527 UefiDevicePathLibCatPrint (Str, L"%s,", L"CHAP_BI");
1528
1529 }
1530
1531 UefiDevicePathLibCatPrint (Str, L"%s)", (ISCSIDevPath->NetworkProtocol == 0) ? L"TCP" : L"reserved");
1532 }
1533
1534 /**
1535 Converts a VLAN device path structure to its string representative.
1536
1537 @param Str The string representative of input device.
1538 @param DevPath The input device path structure.
1539 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1540 of the display node is used, where applicable. If DisplayOnly
1541 is FALSE, then the longer text representation of the display node
1542 is used.
1543 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1544 representation for a device node can be used, where applicable.
1545
1546 **/
1547 VOID
DevPathToTextVlan(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1548 DevPathToTextVlan (
1549 IN OUT POOL_PRINT *Str,
1550 IN VOID *DevPath,
1551 IN BOOLEAN DisplayOnly,
1552 IN BOOLEAN AllowShortcuts
1553 )
1554 {
1555 VLAN_DEVICE_PATH *Vlan;
1556
1557 Vlan = DevPath;
1558 UefiDevicePathLibCatPrint (Str, L"Vlan(%d)", Vlan->VlanId);
1559 }
1560
1561 /**
1562 Converts a Bluetooth device path structure to its string representative.
1563
1564 @param Str The string representative of input device.
1565 @param DevPath The input device path structure.
1566 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1567 of the display node is used, where applicable. If DisplayOnly
1568 is FALSE, then the longer text representation of the display node
1569 is used.
1570 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1571 representation for a device node can be used, where applicable.
1572
1573 **/
1574 VOID
DevPathToTextBluetooth(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1575 DevPathToTextBluetooth (
1576 IN OUT POOL_PRINT *Str,
1577 IN VOID *DevPath,
1578 IN BOOLEAN DisplayOnly,
1579 IN BOOLEAN AllowShortcuts
1580 )
1581 {
1582 BLUETOOTH_DEVICE_PATH *Bluetooth;
1583
1584 Bluetooth = DevPath;
1585 UefiDevicePathLibCatPrint (
1586 Str,
1587 L"Bluetooth(%02x%02x%02x%02x%02x%02x)",
1588 Bluetooth->BD_ADDR.Address[5],
1589 Bluetooth->BD_ADDR.Address[4],
1590 Bluetooth->BD_ADDR.Address[3],
1591 Bluetooth->BD_ADDR.Address[2],
1592 Bluetooth->BD_ADDR.Address[1],
1593 Bluetooth->BD_ADDR.Address[0]
1594 );
1595 }
1596
1597 /**
1598 Converts a Wi-Fi device path structure to its string representative.
1599
1600 @param Str The string representative of input device.
1601 @param DevPath The input device path structure.
1602 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1603 of the display node is used, where applicable. If DisplayOnly
1604 is FALSE, then the longer text representation of the display node
1605 is used.
1606 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1607 representation for a device node can be used, where applicable.
1608
1609 **/
1610 VOID
DevPathToTextWiFi(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1611 DevPathToTextWiFi (
1612 IN OUT POOL_PRINT *Str,
1613 IN VOID *DevPath,
1614 IN BOOLEAN DisplayOnly,
1615 IN BOOLEAN AllowShortcuts
1616 )
1617 {
1618 WIFI_DEVICE_PATH *WiFi;
1619 UINT8 SSId[33];
1620
1621 WiFi = DevPath;
1622
1623 SSId[32] = '\0';
1624 CopyMem (SSId, WiFi->SSId, 32);
1625
1626 UefiDevicePathLibCatPrint (Str, L"Wi-Fi(%a)", SSId);
1627 }
1628
1629 /**
1630 Converts a URI device path structure to its string representative.
1631
1632 @param Str The string representative of input device.
1633 @param DevPath The input device path structure.
1634 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1635 of the display node is used, where applicable. If DisplayOnly
1636 is FALSE, then the longer text representation of the display node
1637 is used.
1638 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1639 representation for a device node can be used, where applicable.
1640
1641 **/
1642 VOID
DevPathToTextUri(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1643 DevPathToTextUri (
1644 IN OUT POOL_PRINT *Str,
1645 IN VOID *DevPath,
1646 IN BOOLEAN DisplayOnly,
1647 IN BOOLEAN AllowShortcuts
1648 )
1649 {
1650 URI_DEVICE_PATH *Uri;
1651 UINTN UriLength;
1652 CHAR8 *UriStr;
1653
1654 //
1655 // Uri in the device path may not be null terminated.
1656 //
1657 Uri = DevPath;
1658 UriLength = DevicePathNodeLength (Uri) - sizeof (URI_DEVICE_PATH);
1659 UriStr = AllocatePool (UriLength + 1);
1660 ASSERT (UriStr != NULL);
1661
1662 CopyMem (UriStr, Uri->Uri, UriLength);
1663 UriStr[UriLength] = '\0';
1664 UefiDevicePathLibCatPrint (Str, L"Uri(%a)", UriStr);
1665 FreePool (UriStr);
1666 }
1667
1668 /**
1669 Converts a Hard drive device path structure to its string representative.
1670
1671 @param Str The string representative of input device.
1672 @param DevPath The input device path structure.
1673 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1674 of the display node is used, where applicable. If DisplayOnly
1675 is FALSE, then the longer text representation of the display node
1676 is used.
1677 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1678 representation for a device node can be used, where applicable.
1679
1680 **/
1681 VOID
DevPathToTextHardDrive(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1682 DevPathToTextHardDrive (
1683 IN OUT POOL_PRINT *Str,
1684 IN VOID *DevPath,
1685 IN BOOLEAN DisplayOnly,
1686 IN BOOLEAN AllowShortcuts
1687 )
1688 {
1689 HARDDRIVE_DEVICE_PATH *Hd;
1690
1691 Hd = DevPath;
1692 switch (Hd->SignatureType) {
1693 case SIGNATURE_TYPE_MBR:
1694 UefiDevicePathLibCatPrint (
1695 Str,
1696 L"HD(%d,%s,0x%08x,",
1697 Hd->PartitionNumber,
1698 L"MBR",
1699 *((UINT32 *) (&(Hd->Signature[0])))
1700 );
1701 break;
1702
1703 case SIGNATURE_TYPE_GUID:
1704 UefiDevicePathLibCatPrint (
1705 Str,
1706 L"HD(%d,%s,%g,",
1707 Hd->PartitionNumber,
1708 L"GPT",
1709 (EFI_GUID *) &(Hd->Signature[0])
1710 );
1711 break;
1712
1713 default:
1714 UefiDevicePathLibCatPrint (
1715 Str,
1716 L"HD(%d,%d,0,",
1717 Hd->PartitionNumber,
1718 Hd->SignatureType
1719 );
1720 break;
1721 }
1722
1723 UefiDevicePathLibCatPrint (Str, L"0x%lx,0x%lx)", Hd->PartitionStart, Hd->PartitionSize);
1724 }
1725
1726 /**
1727 Converts a CDROM device path structure to its string representative.
1728
1729 @param Str The string representative of input device.
1730 @param DevPath The input device path structure.
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 **/
1739 VOID
DevPathToTextCDROM(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1740 DevPathToTextCDROM (
1741 IN OUT POOL_PRINT *Str,
1742 IN VOID *DevPath,
1743 IN BOOLEAN DisplayOnly,
1744 IN BOOLEAN AllowShortcuts
1745 )
1746 {
1747 CDROM_DEVICE_PATH *Cd;
1748
1749 Cd = DevPath;
1750 if (DisplayOnly) {
1751 UefiDevicePathLibCatPrint (Str, L"CDROM(0x%x)", Cd->BootEntry);
1752 return ;
1753 }
1754
1755 UefiDevicePathLibCatPrint (Str, L"CDROM(0x%x,0x%lx,0x%lx)", Cd->BootEntry, Cd->PartitionStart, Cd->PartitionSize);
1756 }
1757
1758 /**
1759 Converts a File device path structure to its string representative.
1760
1761 @param Str The string representative of input device.
1762 @param DevPath The input device path structure.
1763 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1764 of the display node is used, where applicable. If DisplayOnly
1765 is FALSE, then the longer text representation of the display node
1766 is used.
1767 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1768 representation for a device node can be used, where applicable.
1769
1770 **/
1771 VOID
DevPathToTextFilePath(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1772 DevPathToTextFilePath (
1773 IN OUT POOL_PRINT *Str,
1774 IN VOID *DevPath,
1775 IN BOOLEAN DisplayOnly,
1776 IN BOOLEAN AllowShortcuts
1777 )
1778 {
1779 FILEPATH_DEVICE_PATH *Fp;
1780
1781 Fp = DevPath;
1782 UefiDevicePathLibCatPrint (Str, L"%s", Fp->PathName);
1783 }
1784
1785 /**
1786 Converts a Media protocol device path structure to its string representative.
1787
1788 @param Str The string representative of input device.
1789 @param DevPath The input device path structure.
1790 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1791 of the display node is used, where applicable. If DisplayOnly
1792 is FALSE, then the longer text representation of the display node
1793 is used.
1794 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1795 representation for a device node can be used, where applicable.
1796
1797 **/
1798 VOID
DevPathToTextMediaProtocol(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1799 DevPathToTextMediaProtocol (
1800 IN OUT POOL_PRINT *Str,
1801 IN VOID *DevPath,
1802 IN BOOLEAN DisplayOnly,
1803 IN BOOLEAN AllowShortcuts
1804 )
1805 {
1806 MEDIA_PROTOCOL_DEVICE_PATH *MediaProt;
1807
1808 MediaProt = DevPath;
1809 UefiDevicePathLibCatPrint (Str, L"Media(%g)", &MediaProt->Protocol);
1810 }
1811
1812 /**
1813 Converts a Firmware Volume device path structure to its string representative.
1814
1815 @param Str The string representative of input device.
1816 @param DevPath The input device path structure.
1817 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1818 of the display node is used, where applicable. If DisplayOnly
1819 is FALSE, then the longer text representation of the display node
1820 is used.
1821 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1822 representation for a device node can be used, where applicable.
1823
1824 **/
1825 VOID
DevPathToTextFv(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1826 DevPathToTextFv (
1827 IN OUT POOL_PRINT *Str,
1828 IN VOID *DevPath,
1829 IN BOOLEAN DisplayOnly,
1830 IN BOOLEAN AllowShortcuts
1831 )
1832 {
1833 MEDIA_FW_VOL_DEVICE_PATH *Fv;
1834
1835 Fv = DevPath;
1836 UefiDevicePathLibCatPrint (Str, L"Fv(%g)", &Fv->FvName);
1837 }
1838
1839 /**
1840 Converts a Firmware Volume File device path structure to its string representative.
1841
1842 @param Str The string representative of input device.
1843 @param DevPath The input device path structure.
1844 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1845 of the display node is used, where applicable. If DisplayOnly
1846 is FALSE, then the longer text representation of the display node
1847 is used.
1848 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1849 representation for a device node can be used, where applicable.
1850
1851 **/
1852 VOID
DevPathToTextFvFile(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1853 DevPathToTextFvFile (
1854 IN OUT POOL_PRINT *Str,
1855 IN VOID *DevPath,
1856 IN BOOLEAN DisplayOnly,
1857 IN BOOLEAN AllowShortcuts
1858 )
1859 {
1860 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFile;
1861
1862 FvFile = DevPath;
1863 UefiDevicePathLibCatPrint (Str, L"FvFile(%g)", &FvFile->FvFileName);
1864 }
1865
1866 /**
1867 Converts a Relative Offset device path structure to its string representative.
1868
1869 @param Str The string representative of input device.
1870 @param DevPath The input device path structure.
1871 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1872 of the display node is used, where applicable. If DisplayOnly
1873 is FALSE, then the longer text representation of the display node
1874 is used.
1875 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1876 representation for a device node can be used, where applicable.
1877
1878 **/
1879 VOID
DevPathRelativeOffsetRange(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1880 DevPathRelativeOffsetRange (
1881 IN OUT POOL_PRINT *Str,
1882 IN VOID *DevPath,
1883 IN BOOLEAN DisplayOnly,
1884 IN BOOLEAN AllowShortcuts
1885 )
1886 {
1887 MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset;
1888
1889 Offset = DevPath;
1890 UefiDevicePathLibCatPrint (
1891 Str,
1892 L"Offset(0x%lx,0x%lx)",
1893 Offset->StartingOffset,
1894 Offset->EndingOffset
1895 );
1896 }
1897
1898 /**
1899 Converts a Ram Disk device path structure to its string representative.
1900
1901 @param Str The string representative of input device.
1902 @param DevPath The input device path structure.
1903 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1904 of the display node is used, where applicable. If DisplayOnly
1905 is FALSE, then the longer text representation of the display node
1906 is used.
1907 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1908 representation for a device node can be used, where applicable.
1909
1910 **/
1911 VOID
DevPathToTextRamDisk(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1912 DevPathToTextRamDisk (
1913 IN OUT POOL_PRINT *Str,
1914 IN VOID *DevPath,
1915 IN BOOLEAN DisplayOnly,
1916 IN BOOLEAN AllowShortcuts
1917 )
1918 {
1919 MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
1920
1921 RamDisk = DevPath;
1922
1923 if (CompareGuid (&RamDisk->TypeGuid, &gEfiVirtualDiskGuid)) {
1924 UefiDevicePathLibCatPrint (
1925 Str,
1926 L"VirtualDisk(0x%lx,0x%lx,%d)",
1927 LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
1928 LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
1929 RamDisk->Instance
1930 );
1931 } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiVirtualCdGuid)) {
1932 UefiDevicePathLibCatPrint (
1933 Str,
1934 L"VirtualCD(0x%lx,0x%lx,%d)",
1935 LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
1936 LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
1937 RamDisk->Instance
1938 );
1939 } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualDiskGuid)) {
1940 UefiDevicePathLibCatPrint (
1941 Str,
1942 L"PersistentVirtualDisk(0x%lx,0x%lx,%d)",
1943 LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
1944 LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
1945 RamDisk->Instance
1946 );
1947 } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualCdGuid)) {
1948 UefiDevicePathLibCatPrint (
1949 Str,
1950 L"PersistentVirtualCD(0x%lx,0x%lx,%d)",
1951 LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
1952 LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
1953 RamDisk->Instance
1954 );
1955 } else {
1956 UefiDevicePathLibCatPrint (
1957 Str,
1958 L"RamDisk(0x%lx,0x%lx,%d,%g)",
1959 LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
1960 LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
1961 RamDisk->Instance,
1962 &RamDisk->TypeGuid
1963 );
1964 }
1965 }
1966
1967 /**
1968 Converts a BIOS Boot Specification device path structure to its string representative.
1969
1970 @param Str The string representative of input device.
1971 @param DevPath The input device path structure.
1972 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
1973 of the display node is used, where applicable. If DisplayOnly
1974 is FALSE, then the longer text representation of the display node
1975 is used.
1976 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
1977 representation for a device node can be used, where applicable.
1978
1979 **/
1980 VOID
DevPathToTextBBS(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)1981 DevPathToTextBBS (
1982 IN OUT POOL_PRINT *Str,
1983 IN VOID *DevPath,
1984 IN BOOLEAN DisplayOnly,
1985 IN BOOLEAN AllowShortcuts
1986 )
1987 {
1988 BBS_BBS_DEVICE_PATH *Bbs;
1989 CHAR16 *Type;
1990
1991 Bbs = DevPath;
1992 switch (Bbs->DeviceType) {
1993 case BBS_TYPE_FLOPPY:
1994 Type = L"Floppy";
1995 break;
1996
1997 case BBS_TYPE_HARDDRIVE:
1998 Type = L"HD";
1999 break;
2000
2001 case BBS_TYPE_CDROM:
2002 Type = L"CDROM";
2003 break;
2004
2005 case BBS_TYPE_PCMCIA:
2006 Type = L"PCMCIA";
2007 break;
2008
2009 case BBS_TYPE_USB:
2010 Type = L"USB";
2011 break;
2012
2013 case BBS_TYPE_EMBEDDED_NETWORK:
2014 Type = L"Network";
2015 break;
2016
2017 default:
2018 Type = NULL;
2019 break;
2020 }
2021
2022 if (Type != NULL) {
2023 UefiDevicePathLibCatPrint (Str, L"BBS(%s,%a", Type, Bbs->String);
2024 } else {
2025 UefiDevicePathLibCatPrint (Str, L"BBS(0x%x,%a", Bbs->DeviceType, Bbs->String);
2026 }
2027
2028 if (DisplayOnly) {
2029 UefiDevicePathLibCatPrint (Str, L")");
2030 return ;
2031 }
2032
2033 UefiDevicePathLibCatPrint (Str, L",0x%x)", Bbs->StatusFlag);
2034 }
2035
2036 /**
2037 Converts an End-of-Device-Path structure to its string representative.
2038
2039 @param Str The string representative of input device.
2040 @param DevPath The input device path structure.
2041 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
2042 of the display node is used, where applicable. If DisplayOnly
2043 is FALSE, then the longer text representation of the display node
2044 is used.
2045 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
2046 representation for a device node can be used, where applicable.
2047
2048 **/
2049 VOID
DevPathToTextEndInstance(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)2050 DevPathToTextEndInstance (
2051 IN OUT POOL_PRINT *Str,
2052 IN VOID *DevPath,
2053 IN BOOLEAN DisplayOnly,
2054 IN BOOLEAN AllowShortcuts
2055 )
2056 {
2057 UefiDevicePathLibCatPrint (Str, L",");
2058 }
2059
2060 GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_GENERIC_TABLE mUefiDevicePathLibToTextTableGeneric[] = {
2061 {HARDWARE_DEVICE_PATH, L"HardwarePath" },
2062 {ACPI_DEVICE_PATH, L"AcpiPath" },
2063 {MESSAGING_DEVICE_PATH, L"Msg" },
2064 {MEDIA_DEVICE_PATH, L"MediaPath" },
2065 {BBS_DEVICE_PATH, L"BbsPath" },
2066 {0, NULL}
2067 };
2068
2069 /**
2070 Converts an unknown device path structure to its string representative.
2071
2072 @param Str The string representative of input device.
2073 @param DevPath The input device path structure.
2074 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
2075 of the display node is used, where applicable. If DisplayOnly
2076 is FALSE, then the longer text representation of the display node
2077 is used.
2078 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
2079 representation for a device node can be used, where applicable.
2080
2081 **/
2082 VOID
DevPathToTextNodeGeneric(IN OUT POOL_PRINT * Str,IN VOID * DevPath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)2083 DevPathToTextNodeGeneric (
2084 IN OUT POOL_PRINT *Str,
2085 IN VOID *DevPath,
2086 IN BOOLEAN DisplayOnly,
2087 IN BOOLEAN AllowShortcuts
2088 )
2089 {
2090 EFI_DEVICE_PATH_PROTOCOL *Node;
2091 UINTN Index;
2092
2093 Node = DevPath;
2094
2095 for (Index = 0; mUefiDevicePathLibToTextTableGeneric[Index].Text != NULL; Index++) {
2096 if (DevicePathType (Node) == mUefiDevicePathLibToTextTableGeneric[Index].Type) {
2097 break;
2098 }
2099 }
2100
2101 if (mUefiDevicePathLibToTextTableGeneric[Index].Text == NULL) {
2102 //
2103 // It's a node whose type cannot be recognized
2104 //
2105 UefiDevicePathLibCatPrint (Str, L"Path(%d,%d", DevicePathType (Node), DevicePathSubType (Node));
2106 } else {
2107 //
2108 // It's a node whose type can be recognized
2109 //
2110 UefiDevicePathLibCatPrint (Str, L"%s(%d", mUefiDevicePathLibToTextTableGeneric[Index].Text, DevicePathSubType (Node));
2111 }
2112
2113 Index = sizeof (EFI_DEVICE_PATH_PROTOCOL);
2114 if (Index < DevicePathNodeLength (Node)) {
2115 UefiDevicePathLibCatPrint (Str, L",");
2116 for (; Index < DevicePathNodeLength (Node); Index++) {
2117 UefiDevicePathLibCatPrint (Str, L"%02x", ((UINT8 *) Node)[Index]);
2118 }
2119 }
2120
2121 UefiDevicePathLibCatPrint (Str, L")");
2122 }
2123
2124 GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_TABLE mUefiDevicePathLibToTextTable[] = {
2125 {HARDWARE_DEVICE_PATH, HW_PCI_DP, DevPathToTextPci },
2126 {HARDWARE_DEVICE_PATH, HW_PCCARD_DP, DevPathToTextPccard },
2127 {HARDWARE_DEVICE_PATH, HW_MEMMAP_DP, DevPathToTextMemMap },
2128 {HARDWARE_DEVICE_PATH, HW_VENDOR_DP, DevPathToTextVendor },
2129 {HARDWARE_DEVICE_PATH, HW_CONTROLLER_DP, DevPathToTextController },
2130 {HARDWARE_DEVICE_PATH, HW_BMC_DP, DevPathToTextBmc },
2131 {ACPI_DEVICE_PATH, ACPI_DP, DevPathToTextAcpi },
2132 {ACPI_DEVICE_PATH, ACPI_EXTENDED_DP, DevPathToTextAcpiEx },
2133 {ACPI_DEVICE_PATH, ACPI_ADR_DP, DevPathToTextAcpiAdr },
2134 {MESSAGING_DEVICE_PATH, MSG_ATAPI_DP, DevPathToTextAtapi },
2135 {MESSAGING_DEVICE_PATH, MSG_SCSI_DP, DevPathToTextScsi },
2136 {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNEL_DP, DevPathToTextFibre },
2137 {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNELEX_DP, DevPathToTextFibreEx },
2138 {MESSAGING_DEVICE_PATH, MSG_SASEX_DP, DevPathToTextSasEx },
2139 {MESSAGING_DEVICE_PATH, MSG_NVME_NAMESPACE_DP, DevPathToTextNVMe },
2140 {MESSAGING_DEVICE_PATH, MSG_UFS_DP, DevPathToTextUfs },
2141 {MESSAGING_DEVICE_PATH, MSG_SD_DP, DevPathToTextSd },
2142 {MESSAGING_DEVICE_PATH, MSG_1394_DP, DevPathToText1394 },
2143 {MESSAGING_DEVICE_PATH, MSG_USB_DP, DevPathToTextUsb },
2144 {MESSAGING_DEVICE_PATH, MSG_USB_WWID_DP, DevPathToTextUsbWWID },
2145 {MESSAGING_DEVICE_PATH, MSG_DEVICE_LOGICAL_UNIT_DP, DevPathToTextLogicalUnit },
2146 {MESSAGING_DEVICE_PATH, MSG_USB_CLASS_DP, DevPathToTextUsbClass },
2147 {MESSAGING_DEVICE_PATH, MSG_SATA_DP, DevPathToTextSata },
2148 {MESSAGING_DEVICE_PATH, MSG_I2O_DP, DevPathToTextI2O },
2149 {MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP, DevPathToTextMacAddr },
2150 {MESSAGING_DEVICE_PATH, MSG_IPv4_DP, DevPathToTextIPv4 },
2151 {MESSAGING_DEVICE_PATH, MSG_IPv6_DP, DevPathToTextIPv6 },
2152 {MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP, DevPathToTextInfiniBand },
2153 {MESSAGING_DEVICE_PATH, MSG_UART_DP, DevPathToTextUart },
2154 {MESSAGING_DEVICE_PATH, MSG_VENDOR_DP, DevPathToTextVendor },
2155 {MESSAGING_DEVICE_PATH, MSG_ISCSI_DP, DevPathToTextiSCSI },
2156 {MESSAGING_DEVICE_PATH, MSG_VLAN_DP, DevPathToTextVlan },
2157 {MESSAGING_DEVICE_PATH, MSG_URI_DP, DevPathToTextUri },
2158 {MESSAGING_DEVICE_PATH, MSG_BLUETOOTH_DP, DevPathToTextBluetooth },
2159 {MESSAGING_DEVICE_PATH, MSG_WIFI_DP, DevPathToTextWiFi },
2160 {MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP, DevPathToTextHardDrive },
2161 {MEDIA_DEVICE_PATH, MEDIA_CDROM_DP, DevPathToTextCDROM },
2162 {MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP, DevPathToTextVendor },
2163 {MEDIA_DEVICE_PATH, MEDIA_PROTOCOL_DP, DevPathToTextMediaProtocol },
2164 {MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP, DevPathToTextFilePath },
2165 {MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_VOL_DP, DevPathToTextFv },
2166 {MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_FILE_DP, DevPathToTextFvFile },
2167 {MEDIA_DEVICE_PATH, MEDIA_RELATIVE_OFFSET_RANGE_DP, DevPathRelativeOffsetRange },
2168 {MEDIA_DEVICE_PATH, MEDIA_RAM_DISK_DP, DevPathToTextRamDisk },
2169 {BBS_DEVICE_PATH, BBS_BBS_DP, DevPathToTextBBS },
2170 {END_DEVICE_PATH_TYPE, END_INSTANCE_DEVICE_PATH_SUBTYPE, DevPathToTextEndInstance },
2171 {0, 0, NULL}
2172 };
2173
2174 /**
2175 Converts a device node to its string representation.
2176
2177 @param DeviceNode A Pointer to the device node to be converted.
2178 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
2179 of the display node is used, where applicable. If DisplayOnly
2180 is FALSE, then the longer text representation of the display node
2181 is used.
2182 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
2183 representation for a device node can be used, where applicable.
2184
2185 @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
2186 is NULL or there was insufficient memory.
2187
2188 **/
2189 CHAR16 *
2190 EFIAPI
UefiDevicePathLibConvertDeviceNodeToText(IN CONST EFI_DEVICE_PATH_PROTOCOL * DeviceNode,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)2191 UefiDevicePathLibConvertDeviceNodeToText (
2192 IN CONST EFI_DEVICE_PATH_PROTOCOL *DeviceNode,
2193 IN BOOLEAN DisplayOnly,
2194 IN BOOLEAN AllowShortcuts
2195 )
2196 {
2197 POOL_PRINT Str;
2198 UINTN Index;
2199 DEVICE_PATH_TO_TEXT ToText;
2200
2201 if (DeviceNode == NULL) {
2202 return NULL;
2203 }
2204
2205 ZeroMem (&Str, sizeof (Str));
2206
2207 //
2208 // Process the device path node
2209 // If not found, use a generic function
2210 //
2211 ToText = DevPathToTextNodeGeneric;
2212 for (Index = 0; mUefiDevicePathLibToTextTable[Index].Function != NULL; Index++) {
2213 if (DevicePathType (DeviceNode) == mUefiDevicePathLibToTextTable[Index].Type &&
2214 DevicePathSubType (DeviceNode) == mUefiDevicePathLibToTextTable[Index].SubType
2215 ) {
2216 ToText = mUefiDevicePathLibToTextTable[Index].Function;
2217 break;
2218 }
2219 }
2220
2221 //
2222 // Print this node
2223 //
2224 ToText (&Str, (VOID *) DeviceNode, DisplayOnly, AllowShortcuts);
2225
2226 ASSERT (Str.Str != NULL);
2227 return Str.Str;
2228 }
2229
2230 /**
2231 Converts a device path to its text representation.
2232
2233 @param DevicePath A Pointer to the device to be converted.
2234 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation
2235 of the display node is used, where applicable. If DisplayOnly
2236 is FALSE, then the longer text representation of the display node
2237 is used.
2238 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
2239 representation for a device node can be used, where applicable.
2240
2241 @return A pointer to the allocated text representation of the device path or
2242 NULL if DeviceNode is NULL or there was insufficient memory.
2243
2244 **/
2245 CHAR16 *
2246 EFIAPI
UefiDevicePathLibConvertDevicePathToText(IN CONST EFI_DEVICE_PATH_PROTOCOL * DevicePath,IN BOOLEAN DisplayOnly,IN BOOLEAN AllowShortcuts)2247 UefiDevicePathLibConvertDevicePathToText (
2248 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
2249 IN BOOLEAN DisplayOnly,
2250 IN BOOLEAN AllowShortcuts
2251 )
2252 {
2253 POOL_PRINT Str;
2254 EFI_DEVICE_PATH_PROTOCOL *Node;
2255 EFI_DEVICE_PATH_PROTOCOL *AlignedNode;
2256 UINTN Index;
2257 DEVICE_PATH_TO_TEXT ToText;
2258
2259 if (DevicePath == NULL) {
2260 return NULL;
2261 }
2262
2263 ZeroMem (&Str, sizeof (Str));
2264
2265 //
2266 // Process each device path node
2267 //
2268 Node = (EFI_DEVICE_PATH_PROTOCOL *) DevicePath;
2269 while (!IsDevicePathEnd (Node)) {
2270 //
2271 // Find the handler to dump this device path node
2272 // If not found, use a generic function
2273 //
2274 ToText = DevPathToTextNodeGeneric;
2275 for (Index = 0; mUefiDevicePathLibToTextTable[Index].Function != NULL; Index += 1) {
2276
2277 if (DevicePathType (Node) == mUefiDevicePathLibToTextTable[Index].Type &&
2278 DevicePathSubType (Node) == mUefiDevicePathLibToTextTable[Index].SubType
2279 ) {
2280 ToText = mUefiDevicePathLibToTextTable[Index].Function;
2281 break;
2282 }
2283 }
2284 //
2285 // Put a path separator in if needed
2286 //
2287 if ((Str.Count != 0) && (ToText != DevPathToTextEndInstance)) {
2288 if (Str.Str[Str.Count] != L',') {
2289 UefiDevicePathLibCatPrint (&Str, L"/");
2290 }
2291 }
2292
2293 AlignedNode = AllocateCopyPool (DevicePathNodeLength (Node), Node);
2294 //
2295 // Print this node of the device path
2296 //
2297 ToText (&Str, AlignedNode, DisplayOnly, AllowShortcuts);
2298 FreePool (AlignedNode);
2299
2300 //
2301 // Next device path node
2302 //
2303 Node = NextDevicePathNode (Node);
2304 }
2305
2306 if (Str.Str == NULL) {
2307 return AllocateZeroPool (sizeof (CHAR16));
2308 } else {
2309 return Str.Str;
2310 }
2311 }
2312