1 /*++ 2 3 Copyright (c) 1998 Intel Corporation 4 5 Module Name: 6 7 dpath.c 8 9 Abstract: 10 MBR & Device Path functions 11 12 13 14 Revision History 15 16 --*/ 17 18 #include "lib.h" 19 20 #define ALIGN_SIZE(a) ((a % MIN_ALIGNMENT_SIZE) ? MIN_ALIGNMENT_SIZE - (a % MIN_ALIGNMENT_SIZE) : 0) 21 22 23 24 EFI_DEVICE_PATH * 25 DevicePathFromHandle ( 26 IN EFI_HANDLE Handle 27 ) 28 { 29 EFI_STATUS Status; 30 EFI_DEVICE_PATH *DevicePath; 31 32 Status = uefi_call_wrapper(BS->HandleProtocol, 3, Handle, &DevicePathProtocol, (VOID*)&DevicePath); 33 if (EFI_ERROR(Status)) { 34 DevicePath = NULL; 35 } 36 37 return DevicePath; 38 } 39 40 41 EFI_DEVICE_PATH * 42 DevicePathInstance ( 43 IN OUT EFI_DEVICE_PATH **DevicePath, 44 OUT UINTN *Size 45 ) 46 { 47 EFI_DEVICE_PATH *Start, *Next, *DevPath; 48 UINTN Count; 49 50 DevPath = *DevicePath; 51 Start = DevPath; 52 53 if (!DevPath) { 54 return NULL; 55 } 56 57 // 58 // Check for end of device path type 59 // 60 61 for (Count = 0; ; Count++) { 62 Next = NextDevicePathNode(DevPath); 63 64 if (IsDevicePathEndType(DevPath)) { 65 break; 66 } 67 68 if (Count > 01000) { 69 // 70 // BugBug: Debug code to catch bogus device paths 71 // 72 DEBUG((D_ERROR, "DevicePathInstance: DevicePath %x Size %d", *DevicePath, ((UINT8 *) DevPath) - ((UINT8 *) Start) )); 73 DumpHex (0, 0, ((UINT8 *) DevPath) - ((UINT8 *) Start), Start); 74 break; 75 } 76 77 DevPath = Next; 78 } 79 80 ASSERT (DevicePathSubType(DevPath) == END_ENTIRE_DEVICE_PATH_SUBTYPE || 81 DevicePathSubType(DevPath) == END_INSTANCE_DEVICE_PATH_SUBTYPE); 82 83 // 84 // Set next position 85 // 86 87 if (DevicePathSubType(DevPath) == END_ENTIRE_DEVICE_PATH_SUBTYPE) { 88 Next = NULL; 89 } 90 91 *DevicePath = Next; 92 93 // 94 // Return size and start of device path instance 95 // 96 97 *Size = ((UINT8 *) DevPath) - ((UINT8 *) Start); 98 return Start; 99 } 100 101 UINTN 102 DevicePathInstanceCount ( 103 IN EFI_DEVICE_PATH *DevicePath 104 ) 105 { 106 UINTN Count, Size; 107 108 Count = 0; 109 while (DevicePathInstance(&DevicePath, &Size)) { 110 Count += 1; 111 } 112 113 return Count; 114 } 115 116 117 EFI_DEVICE_PATH * 118 AppendDevicePath ( 119 IN EFI_DEVICE_PATH *Src1, 120 IN EFI_DEVICE_PATH *Src2 121 ) 122 // Src1 may have multiple "instances" and each instance is appended 123 // Src2 is appended to each instance is Src1. (E.g., it's possible 124 // to append a new instance to the complete device path by passing 125 // it in Src2) 126 { 127 UINTN Src1Size, Src1Inst, Src2Size, Size; 128 EFI_DEVICE_PATH *Dst, *Inst; 129 UINT8 *DstPos; 130 131 // 132 // If there's only 1 path, just duplicate it 133 // 134 135 if (!Src1) { 136 ASSERT (!IsDevicePathUnpacked (Src2)); 137 return DuplicateDevicePath (Src2); 138 } 139 140 if (!Src2) { 141 ASSERT (!IsDevicePathUnpacked (Src1)); 142 return DuplicateDevicePath (Src1); 143 } 144 145 // 146 // Verify we're not working with unpacked paths 147 // 148 149 // ASSERT (!IsDevicePathUnpacked (Src1)); 150 // ASSERT (!IsDevicePathUnpacked (Src2)); 151 152 // 153 // Append Src2 to every instance in Src1 154 // 155 156 Src1Size = DevicePathSize(Src1); 157 Src1Inst = DevicePathInstanceCount(Src1); 158 Src2Size = DevicePathSize(Src2); 159 Size = Src1Size * Src1Inst + Src2Size; 160 161 Dst = AllocatePool (Size); 162 if (Dst) { 163 DstPos = (UINT8 *) Dst; 164 165 // 166 // Copy all device path instances 167 // 168 169 while ((Inst = DevicePathInstance (&Src1, &Size))) { 170 171 CopyMem(DstPos, Inst, Size); 172 DstPos += Size; 173 174 CopyMem(DstPos, Src2, Src2Size); 175 DstPos += Src2Size; 176 177 CopyMem(DstPos, EndInstanceDevicePath, sizeof(EFI_DEVICE_PATH)); 178 DstPos += sizeof(EFI_DEVICE_PATH); 179 } 180 181 // Change last end marker 182 DstPos -= sizeof(EFI_DEVICE_PATH); 183 CopyMem(DstPos, EndDevicePath, sizeof(EFI_DEVICE_PATH)); 184 } 185 186 return Dst; 187 } 188 189 190 EFI_DEVICE_PATH * 191 AppendDevicePathNode ( 192 IN EFI_DEVICE_PATH *Src1, 193 IN EFI_DEVICE_PATH *Src2 194 ) 195 // Src1 may have multiple "instances" and each instance is appended 196 // Src2 is a signal device path node (without a terminator) that is 197 // appended to each instance is Src1. 198 { 199 EFI_DEVICE_PATH *Temp, *Eop; 200 UINTN Length; 201 202 // 203 // Build a Src2 that has a terminator on it 204 // 205 206 Length = DevicePathNodeLength(Src2); 207 Temp = AllocatePool (Length + sizeof(EFI_DEVICE_PATH)); 208 if (!Temp) { 209 return NULL; 210 } 211 212 CopyMem (Temp, Src2, Length); 213 Eop = NextDevicePathNode(Temp); 214 SetDevicePathEndNode(Eop); 215 216 // 217 // Append device paths 218 // 219 220 Src1 = AppendDevicePath (Src1, Temp); 221 FreePool (Temp); 222 return Src1; 223 } 224 225 226 EFI_DEVICE_PATH * 227 FileDevicePath ( 228 IN EFI_HANDLE Device OPTIONAL, 229 IN CHAR16 *FileName 230 ) 231 /*++ 232 233 N.B. Results are allocated from pool. The caller must FreePool 234 the resulting device path structure 235 236 --*/ 237 { 238 UINTN Size; 239 FILEPATH_DEVICE_PATH *FilePath; 240 EFI_DEVICE_PATH *Eop, *DevicePath; 241 242 Size = StrSize(FileName); 243 FilePath = AllocateZeroPool (Size + SIZE_OF_FILEPATH_DEVICE_PATH + sizeof(EFI_DEVICE_PATH)); 244 DevicePath = NULL; 245 246 if (FilePath) { 247 248 // 249 // Build a file path 250 // 251 252 FilePath->Header.Type = MEDIA_DEVICE_PATH; 253 FilePath->Header.SubType = MEDIA_FILEPATH_DP; 254 SetDevicePathNodeLength (&FilePath->Header, Size + SIZE_OF_FILEPATH_DEVICE_PATH); 255 CopyMem (FilePath->PathName, FileName, Size); 256 Eop = NextDevicePathNode(&FilePath->Header); 257 SetDevicePathEndNode(Eop); 258 259 // 260 // Append file path to device's device path 261 // 262 263 DevicePath = (EFI_DEVICE_PATH *) FilePath; 264 if (Device) { 265 DevicePath = AppendDevicePath ( 266 DevicePathFromHandle(Device), 267 DevicePath 268 ); 269 270 FreePool(FilePath); 271 } 272 } 273 274 return DevicePath; 275 } 276 277 278 279 UINTN 280 DevicePathSize ( 281 IN EFI_DEVICE_PATH *DevPath 282 ) 283 { 284 EFI_DEVICE_PATH *Start; 285 286 // 287 // Search for the end of the device path structure 288 // 289 290 Start = DevPath; 291 while (!IsDevicePathEnd(DevPath)) { 292 DevPath = NextDevicePathNode(DevPath); 293 } 294 295 // 296 // Compute the size 297 // 298 299 return ((UINTN) DevPath - (UINTN) Start) + sizeof(EFI_DEVICE_PATH); 300 } 301 302 EFI_DEVICE_PATH * 303 DuplicateDevicePath ( 304 IN EFI_DEVICE_PATH *DevPath 305 ) 306 { 307 EFI_DEVICE_PATH *NewDevPath; 308 UINTN Size; 309 310 311 // 312 // Compute the size 313 // 314 315 Size = DevicePathSize (DevPath); 316 317 // 318 // Make a copy 319 // 320 321 NewDevPath = AllocatePool (Size); 322 if (NewDevPath) { 323 CopyMem (NewDevPath, DevPath, Size); 324 } 325 326 return NewDevPath; 327 } 328 329 EFI_DEVICE_PATH * 330 UnpackDevicePath ( 331 IN EFI_DEVICE_PATH *DevPath 332 ) 333 { 334 EFI_DEVICE_PATH *Src, *Dest, *NewPath; 335 UINTN Size; 336 337 // 338 // Walk device path and round sizes to valid boundries 339 // 340 341 Src = DevPath; 342 Size = 0; 343 for (; ;) { 344 Size += DevicePathNodeLength(Src); 345 Size += ALIGN_SIZE(Size); 346 347 if (IsDevicePathEnd(Src)) { 348 break; 349 } 350 351 Src = NextDevicePathNode(Src); 352 } 353 354 355 // 356 // Allocate space for the unpacked path 357 // 358 359 NewPath = AllocateZeroPool (Size); 360 if (NewPath) { 361 362 ASSERT (((UINTN)NewPath) % MIN_ALIGNMENT_SIZE == 0); 363 364 // 365 // Copy each node 366 // 367 368 Src = DevPath; 369 Dest = NewPath; 370 for (; ;) { 371 Size = DevicePathNodeLength(Src); 372 CopyMem (Dest, Src, Size); 373 Size += ALIGN_SIZE(Size); 374 SetDevicePathNodeLength (Dest, Size); 375 Dest->Type |= EFI_DP_TYPE_UNPACKED; 376 Dest = (EFI_DEVICE_PATH *) (((UINT8 *) Dest) + Size); 377 378 if (IsDevicePathEnd(Src)) { 379 break; 380 } 381 382 Src = NextDevicePathNode(Src); 383 } 384 } 385 386 return NewPath; 387 } 388 389 390 EFI_DEVICE_PATH* 391 AppendDevicePathInstance ( 392 IN EFI_DEVICE_PATH *Src, 393 IN EFI_DEVICE_PATH *Instance 394 ) 395 { 396 UINT8 *Ptr; 397 EFI_DEVICE_PATH *DevPath; 398 UINTN SrcSize; 399 UINTN InstanceSize; 400 401 if (Src == NULL) { 402 return DuplicateDevicePath (Instance); 403 } 404 SrcSize = DevicePathSize(Src); 405 InstanceSize = DevicePathSize(Instance); 406 Ptr = AllocatePool (SrcSize + InstanceSize); 407 DevPath = (EFI_DEVICE_PATH *)Ptr; 408 ASSERT(DevPath); 409 410 CopyMem (Ptr, Src, SrcSize); 411 // FreePool (Src); 412 413 while (!IsDevicePathEnd(DevPath)) { 414 DevPath = NextDevicePathNode(DevPath); 415 } 416 // 417 // Convert the End to an End Instance, since we are 418 // appending another instacne after this one its a good 419 // idea. 420 // 421 DevPath->SubType = END_INSTANCE_DEVICE_PATH_SUBTYPE; 422 423 DevPath = NextDevicePathNode(DevPath); 424 CopyMem (DevPath, Instance, InstanceSize); 425 return (EFI_DEVICE_PATH *)Ptr; 426 } 427 428 EFI_STATUS 429 LibDevicePathToInterface ( 430 IN EFI_GUID *Protocol, 431 IN EFI_DEVICE_PATH *FilePath, 432 OUT VOID **Interface 433 ) 434 { 435 EFI_STATUS Status; 436 EFI_HANDLE Device; 437 438 Status = uefi_call_wrapper(BS->LocateDevicePath, 3, Protocol, &FilePath, &Device); 439 440 if (!EFI_ERROR(Status)) { 441 442 // If we didn't get a direct match return not found 443 Status = EFI_NOT_FOUND; 444 445 if (IsDevicePathEnd(FilePath)) { 446 447 // 448 // It was a direct match, lookup the protocol interface 449 // 450 451 Status =uefi_call_wrapper(BS->HandleProtocol, 3, Device, Protocol, Interface); 452 } 453 } 454 455 // 456 // If there was an error, do not return an interface 457 // 458 459 if (EFI_ERROR(Status)) { 460 *Interface = NULL; 461 } 462 463 return Status; 464 } 465 466 VOID 467 _DevPathPci ( 468 IN OUT POOL_PRINT *Str, 469 IN VOID *DevPath 470 ) 471 { 472 PCI_DEVICE_PATH *Pci; 473 474 Pci = DevPath; 475 CatPrint(Str, L"Pci(%x|%x)", Pci->Device, Pci->Function); 476 } 477 478 VOID 479 _DevPathPccard ( 480 IN OUT POOL_PRINT *Str, 481 IN VOID *DevPath 482 ) 483 { 484 PCCARD_DEVICE_PATH *Pccard; 485 486 Pccard = DevPath; 487 CatPrint(Str, L"Pccard(Socket%x)", Pccard->SocketNumber); 488 } 489 490 VOID 491 _DevPathMemMap ( 492 IN OUT POOL_PRINT *Str, 493 IN VOID *DevPath 494 ) 495 { 496 MEMMAP_DEVICE_PATH *MemMap; 497 498 MemMap = DevPath; 499 CatPrint(Str, L"MemMap(%d:%x-%x)", 500 MemMap->MemoryType, 501 MemMap->StartingAddress, 502 MemMap->EndingAddress 503 ); 504 } 505 506 VOID 507 _DevPathController ( 508 IN OUT POOL_PRINT *Str, 509 IN VOID *DevPath 510 ) 511 { 512 CONTROLLER_DEVICE_PATH *Controller; 513 514 Controller = DevPath; 515 CatPrint(Str, L"Ctrl(%d)", 516 Controller->Controller 517 ); 518 } 519 520 VOID 521 _DevPathVendor ( 522 IN OUT POOL_PRINT *Str, 523 IN VOID *DevPath 524 ) 525 { 526 VENDOR_DEVICE_PATH *Vendor; 527 CHAR16 *Type; 528 UNKNOWN_DEVICE_VENDOR_DEVICE_PATH *UnknownDevPath; 529 530 Vendor = DevPath; 531 switch (DevicePathType(&Vendor->Header)) { 532 case HARDWARE_DEVICE_PATH: Type = L"Hw"; break; 533 case MESSAGING_DEVICE_PATH: Type = L"Msg"; break; 534 case MEDIA_DEVICE_PATH: Type = L"Media"; break; 535 default: Type = L"?"; break; 536 } 537 538 CatPrint(Str, L"Ven%s(%g", Type, &Vendor->Guid); 539 if (CompareGuid (&Vendor->Guid, &UnknownDevice) == 0) { 540 // 541 // GUID used by EFI to enumerate an EDD 1.1 device 542 // 543 UnknownDevPath = (UNKNOWN_DEVICE_VENDOR_DEVICE_PATH *)Vendor; 544 CatPrint(Str, L":%02x)", UnknownDevPath->LegacyDriveLetter); 545 } else { 546 CatPrint(Str, L")"); 547 } 548 } 549 550 551 VOID 552 _DevPathAcpi ( 553 IN OUT POOL_PRINT *Str, 554 IN VOID *DevPath 555 ) 556 { 557 ACPI_HID_DEVICE_PATH *Acpi; 558 559 Acpi = DevPath; 560 if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) { 561 CatPrint(Str, L"Acpi(PNP%04x,%x)", EISA_ID_TO_NUM (Acpi->HID), Acpi->UID); 562 } else { 563 CatPrint(Str, L"Acpi(%08x,%x)", Acpi->HID, Acpi->UID); 564 } 565 } 566 567 568 VOID 569 _DevPathAtapi ( 570 IN OUT POOL_PRINT *Str, 571 IN VOID *DevPath 572 ) 573 { 574 ATAPI_DEVICE_PATH *Atapi; 575 576 Atapi = DevPath; 577 CatPrint(Str, L"Ata(%s,%s)", 578 Atapi->PrimarySecondary ? L"Secondary" : L"Primary", 579 Atapi->SlaveMaster ? L"Slave" : L"Master" 580 ); 581 } 582 583 VOID 584 _DevPathScsi ( 585 IN OUT POOL_PRINT *Str, 586 IN VOID *DevPath 587 ) 588 { 589 SCSI_DEVICE_PATH *Scsi; 590 591 Scsi = DevPath; 592 CatPrint(Str, L"Scsi(Pun%x,Lun%x)", Scsi->Pun, Scsi->Lun); 593 } 594 595 596 VOID 597 _DevPathFibre ( 598 IN OUT POOL_PRINT *Str, 599 IN VOID *DevPath 600 ) 601 { 602 FIBRECHANNEL_DEVICE_PATH *Fibre; 603 604 Fibre = DevPath; 605 CatPrint(Str, L"Fibre(%lx)", Fibre->WWN); 606 } 607 608 VOID 609 _DevPath1394 ( 610 IN OUT POOL_PRINT *Str, 611 IN VOID *DevPath 612 ) 613 { 614 F1394_DEVICE_PATH *F1394; 615 616 F1394 = DevPath; 617 CatPrint(Str, L"1394(%g)", &F1394->Guid); 618 } 619 620 621 622 VOID 623 _DevPathUsb ( 624 IN OUT POOL_PRINT *Str, 625 IN VOID *DevPath 626 ) 627 { 628 USB_DEVICE_PATH *Usb; 629 630 Usb = DevPath; 631 CatPrint(Str, L"Usb(%x)", Usb->Port); 632 } 633 634 635 VOID 636 _DevPathI2O ( 637 IN OUT POOL_PRINT *Str, 638 IN VOID *DevPath 639 ) 640 { 641 I2O_DEVICE_PATH *I2O; 642 643 I2O = DevPath; 644 CatPrint(Str, L"I2O(%x)", I2O->Tid); 645 } 646 647 VOID 648 _DevPathMacAddr ( 649 IN OUT POOL_PRINT *Str, 650 IN VOID *DevPath 651 ) 652 { 653 MAC_ADDR_DEVICE_PATH *MAC; 654 UINTN HwAddressSize; 655 UINTN Index; 656 657 MAC = DevPath; 658 659 HwAddressSize = sizeof(EFI_MAC_ADDRESS); 660 if (MAC->IfType == 0x01 || MAC->IfType == 0x00) { 661 HwAddressSize = 6; 662 } 663 664 CatPrint(Str, L"Mac("); 665 666 for(Index = 0; Index < HwAddressSize; Index++) { 667 CatPrint(Str, L"%02x",MAC->MacAddress.Addr[Index]); 668 } 669 CatPrint(Str, L")"); 670 } 671 672 VOID 673 _DevPathIPv4 ( 674 IN OUT POOL_PRINT *Str, 675 IN VOID *DevPath 676 ) 677 { 678 IPv4_DEVICE_PATH *IP; 679 680 IP = DevPath; 681 CatPrint(Str, L"IPv4(not-done)"); 682 } 683 684 VOID 685 _DevPathIPv6 ( 686 IN OUT POOL_PRINT *Str, 687 IN VOID *DevPath 688 ) 689 { 690 IPv6_DEVICE_PATH *IP; 691 692 IP = DevPath; 693 CatPrint(Str, L"IP-v6(not-done)"); 694 } 695 696 VOID 697 _DevPathInfiniBand ( 698 IN OUT POOL_PRINT *Str, 699 IN VOID *DevPath 700 ) 701 { 702 INFINIBAND_DEVICE_PATH *InfiniBand; 703 704 InfiniBand = DevPath; 705 CatPrint(Str, L"InfiniBand(not-done)"); 706 } 707 708 VOID 709 _DevPathUart ( 710 IN OUT POOL_PRINT *Str, 711 IN VOID *DevPath 712 ) 713 { 714 UART_DEVICE_PATH *Uart; 715 CHAR8 Parity; 716 717 Uart = DevPath; 718 switch (Uart->Parity) { 719 case 0 : Parity = 'D'; break; 720 case 1 : Parity = 'N'; break; 721 case 2 : Parity = 'E'; break; 722 case 3 : Parity = 'O'; break; 723 case 4 : Parity = 'M'; break; 724 case 5 : Parity = 'S'; break; 725 default : Parity = 'x'; break; 726 } 727 728 if (Uart->BaudRate == 0) { 729 CatPrint(Str, L"Uart(DEFAULT %c",Uart->BaudRate,Parity); 730 } else { 731 CatPrint(Str, L"Uart(%d %c",Uart->BaudRate,Parity); 732 } 733 734 if (Uart->DataBits == 0) { 735 CatPrint(Str, L"D"); 736 } else { 737 CatPrint(Str, L"%d",Uart->DataBits); 738 } 739 740 switch (Uart->StopBits) { 741 case 0 : CatPrint(Str, L"D)"); break; 742 case 1 : CatPrint(Str, L"1)"); break; 743 case 2 : CatPrint(Str, L"1.5)"); break; 744 case 3 : CatPrint(Str, L"2)"); break; 745 default : CatPrint(Str, L"x)"); break; 746 } 747 } 748 749 750 VOID 751 _DevPathHardDrive ( 752 IN OUT POOL_PRINT *Str, 753 IN VOID *DevPath 754 ) 755 { 756 HARDDRIVE_DEVICE_PATH *Hd; 757 758 Hd = DevPath; 759 switch (Hd->SignatureType) { 760 case SIGNATURE_TYPE_MBR: 761 CatPrint(Str, L"HD(Part%d,Sig%08X)", 762 Hd->PartitionNumber, 763 *((UINT32 *)(&(Hd->Signature[0]))) 764 ); 765 break; 766 case SIGNATURE_TYPE_GUID: 767 CatPrint(Str, L"HD(Part%d,Sig%g)", 768 Hd->PartitionNumber, 769 (EFI_GUID *) &(Hd->Signature[0]) 770 ); 771 break; 772 default: 773 CatPrint(Str, L"HD(Part%d,MBRType=%02x,SigType=%02x)", 774 Hd->PartitionNumber, 775 Hd->MBRType, 776 Hd->SignatureType 777 ); 778 break; 779 } 780 } 781 782 VOID 783 _DevPathCDROM ( 784 IN OUT POOL_PRINT *Str, 785 IN VOID *DevPath 786 ) 787 { 788 CDROM_DEVICE_PATH *Cd; 789 790 Cd = DevPath; 791 CatPrint(Str, L"CDROM(Entry%x)", Cd->BootEntry); 792 } 793 794 VOID 795 _DevPathFilePath ( 796 IN OUT POOL_PRINT *Str, 797 IN VOID *DevPath 798 ) 799 { 800 FILEPATH_DEVICE_PATH *Fp; 801 802 Fp = DevPath; 803 CatPrint(Str, L"%s", Fp->PathName); 804 } 805 806 VOID 807 _DevPathMediaProtocol ( 808 IN OUT POOL_PRINT *Str, 809 IN VOID *DevPath 810 ) 811 { 812 MEDIA_PROTOCOL_DEVICE_PATH *MediaProt; 813 814 MediaProt = DevPath; 815 CatPrint(Str, L"%g", &MediaProt->Protocol); 816 } 817 818 VOID 819 _DevPathBssBss ( 820 IN OUT POOL_PRINT *Str, 821 IN VOID *DevPath 822 ) 823 { 824 BBS_BBS_DEVICE_PATH *Bss; 825 CHAR16 *Type; 826 827 Bss = DevPath; 828 switch (Bss->DeviceType) { 829 case BBS_TYPE_FLOPPY: Type = L"Floppy"; break; 830 case BBS_TYPE_HARDDRIVE: Type = L"Harddrive"; break; 831 case BBS_TYPE_CDROM: Type = L"CDROM"; break; 832 case BBS_TYPE_PCMCIA: Type = L"PCMCIA"; break; 833 case BBS_TYPE_USB: Type = L"Usb"; break; 834 case BBS_TYPE_EMBEDDED_NETWORK: Type = L"Net"; break; 835 default: Type = L"?"; break; 836 } 837 838 CatPrint(Str, L"Bss-%s(%a)", Type, Bss->String); 839 } 840 841 842 VOID 843 _DevPathEndInstance ( 844 IN OUT POOL_PRINT *Str, 845 IN VOID *DevPath 846 ) 847 { 848 CatPrint(Str, L","); 849 } 850 851 VOID 852 _DevPathNodeUnknown ( 853 IN OUT POOL_PRINT *Str, 854 IN VOID *DevPath 855 ) 856 { 857 CatPrint(Str, L"?"); 858 } 859 860 861 struct { 862 UINT8 Type; 863 UINT8 SubType; 864 VOID (*Function)(POOL_PRINT *, VOID *); 865 } DevPathTable[] = { 866 { HARDWARE_DEVICE_PATH, HW_PCI_DP, _DevPathPci}, 867 { HARDWARE_DEVICE_PATH, HW_PCCARD_DP, _DevPathPccard}, 868 { HARDWARE_DEVICE_PATH, HW_MEMMAP_DP, _DevPathMemMap}, 869 { HARDWARE_DEVICE_PATH, HW_VENDOR_DP, _DevPathVendor}, 870 { HARDWARE_DEVICE_PATH, HW_CONTROLLER_DP, _DevPathController}, 871 { ACPI_DEVICE_PATH, ACPI_DP, _DevPathAcpi}, 872 { MESSAGING_DEVICE_PATH, MSG_ATAPI_DP, _DevPathAtapi}, 873 { MESSAGING_DEVICE_PATH, MSG_SCSI_DP, _DevPathScsi}, 874 { MESSAGING_DEVICE_PATH, MSG_FIBRECHANNEL_DP, _DevPathFibre}, 875 { MESSAGING_DEVICE_PATH, MSG_1394_DP, _DevPath1394}, 876 { MESSAGING_DEVICE_PATH, MSG_USB_DP, _DevPathUsb}, 877 { MESSAGING_DEVICE_PATH, MSG_I2O_DP, _DevPathI2O}, 878 { MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP, _DevPathMacAddr}, 879 { MESSAGING_DEVICE_PATH, MSG_IPv4_DP, _DevPathIPv4}, 880 { MESSAGING_DEVICE_PATH, MSG_IPv6_DP, _DevPathIPv6}, 881 { MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP, _DevPathInfiniBand}, 882 { MESSAGING_DEVICE_PATH, MSG_UART_DP, _DevPathUart}, 883 { MESSAGING_DEVICE_PATH, MSG_VENDOR_DP, _DevPathVendor}, 884 { MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP, _DevPathHardDrive}, 885 { MEDIA_DEVICE_PATH, MEDIA_CDROM_DP, _DevPathCDROM}, 886 { MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP, _DevPathVendor}, 887 { MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP, _DevPathFilePath}, 888 { MEDIA_DEVICE_PATH, MEDIA_PROTOCOL_DP, _DevPathMediaProtocol}, 889 { BBS_DEVICE_PATH, BBS_BBS_DP, _DevPathBssBss}, 890 { END_DEVICE_PATH_TYPE, END_INSTANCE_DEVICE_PATH_SUBTYPE, _DevPathEndInstance}, 891 { 0, 0, NULL} 892 }; 893 894 895 CHAR16 * 896 DevicePathToStr ( 897 EFI_DEVICE_PATH *DevPath 898 ) 899 /*++ 900 901 Turns the Device Path into a printable string. Allcoates 902 the string from pool. The caller must FreePool the returned 903 string. 904 905 --*/ 906 { 907 POOL_PRINT Str; 908 EFI_DEVICE_PATH *DevPathNode; 909 VOID (*DumpNode)(POOL_PRINT *, VOID *); 910 UINTN Index, NewSize; 911 912 ZeroMem(&Str, sizeof(Str)); 913 914 // 915 // Unpacked the device path 916 // 917 918 DevPath = UnpackDevicePath(DevPath); 919 ASSERT (DevPath); 920 921 922 // 923 // Process each device path node 924 // 925 926 DevPathNode = DevPath; 927 while (!IsDevicePathEnd(DevPathNode)) { 928 // 929 // Find the handler to dump this device path node 930 // 931 932 DumpNode = NULL; 933 for (Index = 0; DevPathTable[Index].Function; Index += 1) { 934 935 if (DevicePathType(DevPathNode) == DevPathTable[Index].Type && 936 DevicePathSubType(DevPathNode) == DevPathTable[Index].SubType) { 937 DumpNode = DevPathTable[Index].Function; 938 break; 939 } 940 } 941 942 // 943 // If not found, use a generic function 944 // 945 946 if (!DumpNode) { 947 DumpNode = _DevPathNodeUnknown; 948 } 949 950 // 951 // Put a path seperator in if needed 952 // 953 954 if (Str.len && DumpNode != _DevPathEndInstance) { 955 CatPrint (&Str, L"/"); 956 } 957 958 // 959 // Print this node of the device path 960 // 961 962 DumpNode (&Str, DevPathNode); 963 964 // 965 // Next device path node 966 // 967 968 DevPathNode = NextDevicePathNode(DevPathNode); 969 } 970 971 // 972 // Shrink pool used for string allocation 973 // 974 975 FreePool (DevPath); 976 NewSize = (Str.len + 1) * sizeof(CHAR16); 977 Str.str = ReallocatePool (Str.str, NewSize, NewSize); 978 Str.str[Str.len] = 0; 979 return Str.str; 980 } 981 982 BOOLEAN 983 LibMatchDevicePaths ( 984 IN EFI_DEVICE_PATH *Multi, 985 IN EFI_DEVICE_PATH *Single 986 ) 987 { 988 EFI_DEVICE_PATH *DevicePath, *DevicePathInst; 989 UINTN Size; 990 991 if (!Multi || !Single) { 992 return FALSE; 993 } 994 995 DevicePath = Multi; 996 while ((DevicePathInst = DevicePathInstance (&DevicePath, &Size))) { 997 if (CompareMem (Single, DevicePathInst, Size) == 0) { 998 return TRUE; 999 } 1000 } 1001 return FALSE; 1002 } 1003 1004 EFI_DEVICE_PATH * 1005 LibDuplicateDevicePathInstance ( 1006 IN EFI_DEVICE_PATH *DevPath 1007 ) 1008 { 1009 EFI_DEVICE_PATH *NewDevPath,*DevicePathInst,*Temp; 1010 UINTN Size = 0; 1011 1012 // 1013 // get the size of an instance from the input 1014 // 1015 1016 Temp = DevPath; 1017 DevicePathInst = DevicePathInstance (&Temp, &Size); 1018 1019 // 1020 // Make a copy and set proper end type 1021 // 1022 NewDevPath = NULL; 1023 if (Size) { 1024 NewDevPath = AllocatePool (Size + sizeof(EFI_DEVICE_PATH)); 1025 } 1026 1027 if (NewDevPath) { 1028 CopyMem (NewDevPath, DevicePathInst, Size); 1029 Temp = NextDevicePathNode(NewDevPath); 1030 SetDevicePathEndNode(Temp); 1031 } 1032 1033 return NewDevPath; 1034 } 1035 1036
