/** Build device path for device. @param BaseDevicePath Base device path. @param Drive Legacy drive. @param DevicePath Device path for output. **/ VOID SetBiosInitBlockIoDevicePath ( IN EFI_DEVICE_PATH_PROTOCOL *BaseDevicePath, IN BIOS_LEGACY_DRIVE *Drive, OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath ) { EFI_STATUS Status; BLOCKIO_VENDOR_DEVICE_PATH VendorNode; Status = EFI_UNSUPPORTED; // // BugBug: Check for memory leaks! // if (Drive->EddVersion == EDD_VERSION_30) { // // EDD 3.0 case. // Status = BuildEdd30DevicePath (BaseDevicePath, Drive, DevicePath); } if (EFI_ERROR (Status)) { // // EDD 1.1 device case or it is unrecognized EDD 3.0 device // ZeroMem (&VendorNode, sizeof (VendorNode)); VendorNode.DevicePath.Header.Type = HARDWARE_DEVICE_PATH; VendorNode.DevicePath.Header.SubType = HW_VENDOR_DP; SetDevicePathNodeLength (&VendorNode.DevicePath.Header, sizeof (VendorNode)); CopyMem (&VendorNode.DevicePath.Guid, &gBlockIoVendorGuid, sizeof (EFI_GUID)); VendorNode.LegacyDriveLetter = Drive->Number; *DevicePath = AppendDevicePathNode (BaseDevicePath, &VendorNode.DevicePath.Header); } }
EFI_DEVICE_PATH_PROTOCOL * CreatePciDevicePath ( IN EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath, IN PCI_IO_DEVICE *PciIoDevice ) /*++ Routine Description: Arguments: Returns: None --*/ { PCI_DEVICE_PATH PciNode; // // Create PCI device path // PciNode.Header.Type = HARDWARE_DEVICE_PATH; PciNode.Header.SubType = HW_PCI_DP; SetDevicePathNodeLength (&PciNode.Header, sizeof (PciNode)); PciNode.Device = PciIoDevice->DeviceNumber; PciNode.Function = PciIoDevice->FunctionNumber; PciIoDevice->DevicePath = AppendDevicePathNode (ParentDevicePath, &PciNode.Header); return PciIoDevice->DevicePath; }
STATIC EFI_STATUS EFIAPI SasV1ExtScsiPassThruBuildDevicePath ( IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This, IN UINT8 *Target, IN UINT64 Lun, IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath ) { EFI_DEVICE_PATH_PROTOCOL *NewDevicePathNode; EFI_DEV_PATH EndNode; EFI_DEV_PATH Node; ZeroMem (&Node, sizeof (Node)); Node.DevPath.Type = HARDWARE_DEVICE_PATH; Node.DevPath.SubType = HW_PCI_DP; SetDevicePathNodeLength (&Node.DevPath, sizeof (PCI_DEVICE_PATH)); SetDevicePathEndNode (&EndNode.DevPath); NewDevicePathNode = AppendDevicePathNode (&EndNode.DevPath, &Node.DevPath); *DevicePath = NewDevicePathNode; return EFI_SUCCESS; }
EFIAPI AppendDeviceNodeProtocolInterface ( IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathNode ) { return AppendDevicePathNode (DevicePath, DevicePathNode); }
EFIAPI GetHIDevicePath ( IN EFI_DEVICE_PATH_PROTOCOL *DevicePath ) { UINTN NonHIDevicePathNodeCount; UINTN Index; EFI_DEV_PATH Node; EFI_DEVICE_PATH_PROTOCOL *HIDevicePath; EFI_DEVICE_PATH_PROTOCOL *TempDevicePath; ASSERT(DevicePath != NULL); NonHIDevicePathNodeCount = 0; HIDevicePath = AllocateZeroPool (sizeof (EFI_DEVICE_PATH_PROTOCOL)); SetDevicePathEndNode (HIDevicePath); Node.DevPath.Type = END_DEVICE_PATH_TYPE; Node.DevPath.SubType = END_INSTANCE_DEVICE_PATH_SUBTYPE; Node.DevPath.Length[0] = (UINT8)sizeof (EFI_DEVICE_PATH_PROTOCOL); Node.DevPath.Length[1] = 0; while (!IsDevicePathEnd (DevicePath)) { if (IsHIDevicePathNode (DevicePath)) { for (Index = 0; Index < NonHIDevicePathNodeCount; Index++) { TempDevicePath = AppendDevicePathNode (HIDevicePath, &Node.DevPath); FreePool (HIDevicePath); HIDevicePath = TempDevicePath; } TempDevicePath = AppendDevicePathNode (HIDevicePath, DevicePath); FreePool (HIDevicePath); HIDevicePath = TempDevicePath; } else { NonHIDevicePathNodeCount++; } // // Next device path node // DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) NextDevicePathNode (DevicePath); } return HIDevicePath; }
EFI_STATUS PreparePciSerialDevicePath ( IN EFI_HANDLE DeviceHandle ) /*++ Routine Description: Add PCI Serial to ConOut, ConIn, ErrOut. PCI Serial: 07 00 02 Arguments: DeviceHandle - Handle of PCIIO protocol. Returns: EFI_SUCCESS - PCI Serial is added to ConOut, ConIn, and ErrOut. EFI_STATUS - No PCI Serial device is added. --*/ { EFI_STATUS Status; EFI_DEVICE_PATH_PROTOCOL *DevicePath; DevicePath = NULL; Status = gBS->HandleProtocol ( DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID*)&DevicePath ); if (EFI_ERROR (Status)) { return Status; } DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gUartDeviceNode); DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gTerminalTypeDeviceNode); BdsLibUpdateConsoleVariable (VarConsoleOut, DevicePath, NULL); BdsLibUpdateConsoleVariable (VarConsoleInp, DevicePath, NULL); BdsLibUpdateConsoleVariable (VarErrorOut, DevicePath, NULL); return EFI_SUCCESS; }
EFI_STATUS BdsLoadOptionFileSystemUpdateDevicePath ( IN EFI_DEVICE_PATH *OldDevicePath, IN CHAR16* FileName, OUT EFI_DEVICE_PATH_PROTOCOL **NewDevicePath ) { EFI_STATUS Status; CHAR16 BootFilePath[BOOT_DEVICE_FILEPATH_MAX]; UINTN BootFilePathSize; FILEPATH_DEVICE_PATH* EndingDevicePath; FILEPATH_DEVICE_PATH* FilePathDevicePath; EFI_DEVICE_PATH* DevicePath; DevicePath = DuplicateDevicePath (OldDevicePath); EndingDevicePath = (FILEPATH_DEVICE_PATH*)GetLastDevicePathNode (DevicePath); Print(L"File path of the %s: ", FileName); StrnCpy (BootFilePath, EndingDevicePath->PathName, BOOT_DEVICE_FILEPATH_MAX); Status = EditHIInputStr (BootFilePath, BOOT_DEVICE_FILEPATH_MAX); if (EFI_ERROR(Status)) { return Status; } BootFilePathSize = StrSize(BootFilePath); if (BootFilePathSize == 2) { *NewDevicePath = NULL; return EFI_NOT_FOUND; } // Create the FilePath Device Path node FilePathDevicePath = (FILEPATH_DEVICE_PATH*)AllocatePool(SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize); if (NULL == FilePathDevicePath) { return EFI_INVALID_PARAMETER; } FilePathDevicePath->Header.Type = MEDIA_DEVICE_PATH; FilePathDevicePath->Header.SubType = MEDIA_FILEPATH_DP; SetDevicePathNodeLength (FilePathDevicePath, SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize); CopyMem (FilePathDevicePath->PathName, BootFilePath, BootFilePathSize); // Generate the new Device Path by replacing the last node by the updated node SetDevicePathEndNode (EndingDevicePath); *NewDevicePath = AppendDevicePathNode (DevicePath, (CONST EFI_DEVICE_PATH_PROTOCOL *)FilePathDevicePath); FreePool(DevicePath); return EFI_SUCCESS; }
EFI_DEVICE_PATH * FvFileDevicePath ( IN EFI_HANDLE FvHandle, IN EFI_GUID *NameGuid ) { EFI_DEVICE_PATH_PROTOCOL *DevicePath; MEDIA_FW_VOL_FILEPATH_DEVICE_PATH NewNode; DevicePath = DevicePathFromHandle (FvHandle); EfiInitializeFwVolDevicepathNode (&NewNode, NameGuid); return AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&NewNode); }
EFI_DEVICE_PATH_PROTOCOL * WinNtBusCreateDevicePath ( IN EFI_DEVICE_PATH_PROTOCOL *RootDevicePath, IN EFI_GUID *Guid, IN UINT16 InstanceNumber ) /*++ Routine Description: Create a device path node using Guid and InstanceNumber and append it to the passed in RootDevicePath Arguments: RootDevicePath - Root of the device path to return. Guid - GUID to use in vendor device path node. InstanceNumber - Instance number to use in the vendor device path. This argument is needed to make sure each device path is unique. Returns: EFI_DEVICE_PATH_PROTOCOL --*/ { WIN_NT_VENDOR_DEVICE_PATH_NODE DevicePath; DevicePath.VendorDevicePath.Header.Type = HARDWARE_DEVICE_PATH; DevicePath.VendorDevicePath.Header.SubType = HW_VENDOR_DP; SetDevicePathNodeLength (&DevicePath.VendorDevicePath.Header, sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE)); // // The GUID defines the Class // CopyMem (&DevicePath.VendorDevicePath.Guid, Guid, sizeof (EFI_GUID)); // // Add an instance number so we can make sure there are no Device Path // duplication. // DevicePath.Instance = InstanceNumber; return AppendDevicePathNode ( RootDevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &DevicePath ); }
VOID PlatformRegisterFvBootOption ( EFI_GUID *FileGuid, CHAR16 *Description, UINT32 Attributes ) { EFI_STATUS Status; UINTN OptionIndex; EFI_BOOT_MANAGER_LOAD_OPTION NewOption; EFI_BOOT_MANAGER_LOAD_OPTION *BootOptions; UINTN BootOptionCount; MEDIA_FW_VOL_FILEPATH_DEVICE_PATH FileNode; EFI_LOADED_IMAGE_PROTOCOL *LoadedImage; EFI_DEVICE_PATH_PROTOCOL *DevicePath; Status = gBS->HandleProtocol (gImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &LoadedImage); ASSERT_EFI_ERROR (Status); EfiInitializeFwVolDevicepathNode (&FileNode, FileGuid); DevicePath = AppendDevicePathNode ( DevicePathFromHandle (LoadedImage->DeviceHandle), (EFI_DEVICE_PATH_PROTOCOL *) &FileNode ); Status = EfiBootManagerInitializeLoadOption ( &NewOption, LoadOptionNumberUnassigned, LoadOptionTypeBoot, Attributes, Description, DevicePath, NULL, 0 ); if (!EFI_ERROR (Status)) { BootOptions = EfiBootManagerGetLoadOptions (&BootOptionCount, LoadOptionTypeBoot); OptionIndex = PlatformFindLoadOption (&NewOption, BootOptions, BootOptionCount); if (OptionIndex == -1) { Status = EfiBootManagerAddLoadOptionVariable (&NewOption, (UINTN) -1); ASSERT_EFI_ERROR (Status); } EfiBootManagerFreeLoadOption (&NewOption); EfiBootManagerFreeLoadOptions (BootOptions, BootOptionCount); } }
STATIC EFI_STATUS CreatePlatformBootOptionFromGuid ( IN EFI_GUID *FileGuid, IN CHAR16 *Description, IN OUT EFI_BOOT_MANAGER_LOAD_OPTION *BootOption ) { EFI_STATUS Status; EFI_DEVICE_PATH *DevicePath; EFI_DEVICE_PATH *TempDevicePath; EFI_LOADED_IMAGE_PROTOCOL *LoadedImage; MEDIA_FW_VOL_FILEPATH_DEVICE_PATH FileNode; Status = gBS->HandleProtocol ( gImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &LoadedImage ); ASSERT_EFI_ERROR (Status); EfiInitializeFwVolDevicepathNode (&FileNode, FileGuid); TempDevicePath = DevicePathFromHandle (LoadedImage->DeviceHandle); ASSERT (TempDevicePath != NULL); DevicePath = AppendDevicePathNode ( TempDevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &FileNode ); ASSERT (DevicePath != NULL); Status = EfiBootManagerInitializeLoadOption ( BootOption, LoadOptionNumberUnassigned, LoadOptionTypeBoot, LOAD_OPTION_ACTIVE, Description, DevicePath, NULL, 0 ); FreePool (DevicePath); return Status; }
/** Generate device path include the input file guid info. @param FileGuid Input file guid for the BootManagerMenuApp. @retval DevicePath for BootManagerMenuApp. **/ EFI_DEVICE_PATH * FvFilePath ( EFI_GUID *FileGuid ) { EFI_STATUS Status; EFI_LOADED_IMAGE_PROTOCOL *LoadedImage; MEDIA_FW_VOL_FILEPATH_DEVICE_PATH FileNode; EfiInitializeFwVolDevicepathNode (&FileNode, FileGuid); Status = gBS->HandleProtocol ( gImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &LoadedImage ); ASSERT_EFI_ERROR (Status); return AppendDevicePathNode ( DevicePathFromHandle (LoadedImage->DeviceHandle), (EFI_DEVICE_PATH_PROTOCOL *) &FileNode ); }
/** Update the parameters of a TFTP boot option The function asks sequentially to update the IPv4 parameters as well as the boot file path, providing the previously set value if any. @param[in] OldDevicePath Current complete device path of the Tftp boot option. This has to be a valid complete Tftp boot option path. By complete, we mean that it is not only the Tftp specific end part built by the "BdsLoadOptionTftpCreateDevicePath()" function. This path is handled as read only. @param[in] FileName Description of the file the path is asked for @param[out] NewDevicePath Pointer to the new complete device path. @retval EFI_SUCCESS Update completed @retval EFI_ABORTED Update aborted by the user @retval EFI_OUT_OF_RESOURCES Fail to perform the update due to lack of resource **/ EFI_STATUS BdsLoadOptionTftpUpdateDevicePath ( IN EFI_DEVICE_PATH *OldDevicePath, IN CHAR16 *FileName, OUT EFI_DEVICE_PATH_PROTOCOL **NewDevicePath ) { EFI_STATUS Status; EFI_DEVICE_PATH *DevicePath; EFI_DEVICE_PATH *DevicePathNode; UINT8 *Ipv4NodePtr; IPv4_DEVICE_PATH Ipv4Node; BOOLEAN IsDHCP; EFI_IP_ADDRESS OldIp; EFI_IP_ADDRESS OldSubnetMask; EFI_IP_ADDRESS OldGatewayIp; EFI_IP_ADDRESS LocalIp; EFI_IP_ADDRESS SubnetMask; EFI_IP_ADDRESS GatewayIp; EFI_IP_ADDRESS RemoteIp; UINT8 *FileNodePtr; CHAR16 BootFilePath[BOOT_DEVICE_FILEPATH_MAX]; UINTN PathSize; UINTN BootFilePathSize; FILEPATH_DEVICE_PATH *NewFilePathNode; Ipv4NodePtr = NULL; // // Make a copy of the complete device path that is made of : // the device path of the device that support the Simple Network protocol // followed by an IPv4 node (type IPv4_DEVICE_PATH), // followed by a file path node (type FILEPATH_DEVICE_PATH) and ended up // by an end node. The IPv6 case is not handled yet. // DevicePath = DuplicateDevicePath (OldDevicePath); if (DevicePath == NULL) { Status = EFI_OUT_OF_RESOURCES; goto ErrorExit; } // // Because of the check done by "BdsLoadOptionTftpIsSupported()" prior to the // call to this function, we know that the device path ends with an IPv4 node // followed by a file path node and finally an end node. To get the address of // the last IPv4 node, we loop over the whole device path, noting down the // address of each encountered IPv4 node. // for (DevicePathNode = DevicePath; !IsDevicePathEnd (DevicePathNode); DevicePathNode = NextDevicePathNode (DevicePathNode)) { if (IS_DEVICE_PATH_NODE (DevicePathNode, MESSAGING_DEVICE_PATH, MSG_IPv4_DP)) { Ipv4NodePtr = (UINT8*)DevicePathNode; } } // Copy for alignment of the IPv4 node data CopyMem (&Ipv4Node, Ipv4NodePtr, sizeof (IPv4_DEVICE_PATH)); Print (L"Get the IP address from DHCP: "); Status = GetHIInputBoolean (&IsDHCP); if (EFI_ERROR (Status)) { goto ErrorExit; } if (!IsDHCP) { Print (L"Local static IP address: "); if (Ipv4Node.StaticIpAddress) { CopyMem (&OldIp.v4, &Ipv4Node.LocalIpAddress, sizeof (EFI_IPv4_ADDRESS)); Status = EditHIInputIP (&OldIp, &LocalIp); } else { Status = GetHIInputIP (&LocalIp); } if (EFI_ERROR (Status)) { goto ErrorExit; } Print (L"Get the network mask: "); if (Ipv4Node.StaticIpAddress) { CopyMem (&OldSubnetMask.v4, &Ipv4Node.SubnetMask, sizeof (EFI_IPv4_ADDRESS)); Status = EditHIInputIP (&OldSubnetMask, &SubnetMask); } else { Status = GetHIInputIP (&SubnetMask); } if (EFI_ERROR (Status)) { goto ErrorExit; } Print (L"Get the gateway IP address: "); if (Ipv4Node.StaticIpAddress) { CopyMem (&OldGatewayIp.v4, &Ipv4Node.GatewayIpAddress, sizeof (EFI_IPv4_ADDRESS)); Status = EditHIInputIP (&OldGatewayIp, &GatewayIp); } else { Status = GetHIInputIP (&GatewayIp); } if (EFI_ERROR (Status)) { goto ErrorExit; } } Print (L"TFTP server IP address: "); // Copy remote IPv4 address into IPv4 or IPv6 union CopyMem (&OldIp.v4, &Ipv4Node.RemoteIpAddress, sizeof (EFI_IPv4_ADDRESS)); Status = EditHIInputIP (&OldIp, &RemoteIp); if (EFI_ERROR (Status)) { goto ErrorExit; } // Get the path of the boot file and its size in number of bytes FileNodePtr = Ipv4NodePtr + sizeof (IPv4_DEVICE_PATH); BootFilePathSize = DevicePathNodeLength (FileNodePtr) - SIZE_OF_FILEPATH_DEVICE_PATH; // // Ask for update of the boot file path // do { // Copy for 2-byte alignment of the Unicode string CopyMem ( BootFilePath, FileNodePtr + SIZE_OF_FILEPATH_DEVICE_PATH, MIN (BootFilePathSize, BOOT_DEVICE_FILEPATH_MAX) ); BootFilePath[BOOT_DEVICE_FILEPATH_MAX - 1] = L'\0'; Print (L"File path of the %s: ", FileName); Status = EditHIInputStr (BootFilePath, BOOT_DEVICE_FILEPATH_MAX); if (EFI_ERROR (Status)) { goto ErrorExit; } PathSize = StrSize (BootFilePath); if (PathSize > 2) { break; } // Empty string, give the user another try Print (L"Empty string - Invalid path\n"); } while (PathSize <= 2) ; // // Update the IPv4 node. IPv6 case not handled yet. // if (IsDHCP) { Ipv4Node.StaticIpAddress = FALSE; ZeroMem (&Ipv4Node.LocalIpAddress, sizeof (EFI_IPv4_ADDRESS)); ZeroMem (&Ipv4Node.SubnetMask, sizeof (EFI_IPv4_ADDRESS)); ZeroMem (&Ipv4Node.GatewayIpAddress, sizeof (EFI_IPv4_ADDRESS)); } else { Ipv4Node.StaticIpAddress = TRUE; CopyMem (&Ipv4Node.LocalIpAddress, &LocalIp.v4, sizeof (EFI_IPv4_ADDRESS)); CopyMem (&Ipv4Node.SubnetMask, &SubnetMask.v4, sizeof (EFI_IPv4_ADDRESS)); CopyMem (&Ipv4Node.GatewayIpAddress, &GatewayIp.v4, sizeof (EFI_IPv4_ADDRESS)); } CopyMem (&Ipv4Node.RemoteIpAddress, &RemoteIp.v4, sizeof (EFI_IPv4_ADDRESS)); CopyMem (Ipv4NodePtr, &Ipv4Node, sizeof (IPv4_DEVICE_PATH)); // // Create the new file path node // NewFilePathNode = (FILEPATH_DEVICE_PATH*)AllocatePool ( SIZE_OF_FILEPATH_DEVICE_PATH + PathSize ); NewFilePathNode->Header.Type = MEDIA_DEVICE_PATH; NewFilePathNode->Header.SubType = MEDIA_FILEPATH_DP; SetDevicePathNodeLength ( NewFilePathNode, SIZE_OF_FILEPATH_DEVICE_PATH + PathSize ); CopyMem (NewFilePathNode->PathName, BootFilePath, PathSize); // // Generate the new Device Path by replacing the file path node at address // "FileNodePtr" by the new one "NewFilePathNode" and return its address. // SetDevicePathEndNode (FileNodePtr); *NewDevicePath = AppendDevicePathNode ( DevicePath, (CONST EFI_DEVICE_PATH_PROTOCOL*)NewFilePathNode ); ErrorExit: if (DevicePath != NULL) { FreePool (DevicePath) ; } return Status; }
/** Create a child handle for a logical block device that represents the bytes Start to End of the Parent Block IO device. @param[in] This Protocol instance pointer. @param[in] ParentHandle Parent Handle for new child. @param[in] ParentDiskIo Parent DiskIo interface. @param[in] ParentDiskIo2 Parent DiskIo2 interface. @param[in] ParentBlockIo Parent BlockIo interface. @param[in] ParentBlockIo2 Parent BlockIo2 interface. @param[in] ParentDevicePath Parent Device Path. @param[in] DevicePathNode Child Device Path node. @param[in] Start Start Block. @param[in] End End Block. @param[in] BlockSize Child block size. @param[in] InstallEspGuid Flag to install EFI System Partition GUID on handle. @retval EFI_SUCCESS A child handle was added. @retval other A child handle was not added. **/ EFI_STATUS PartitionInstallChildHandle ( IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE ParentHandle, IN EFI_DISK_IO_PROTOCOL *ParentDiskIo, IN EFI_DISK_IO2_PROTOCOL *ParentDiskIo2, IN EFI_BLOCK_IO_PROTOCOL *ParentBlockIo, IN EFI_BLOCK_IO2_PROTOCOL *ParentBlockIo2, IN EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath, IN EFI_DEVICE_PATH_PROTOCOL *DevicePathNode, IN EFI_LBA Start, IN EFI_LBA End, IN UINT32 BlockSize, IN BOOLEAN InstallEspGuid ) { EFI_STATUS Status; PARTITION_PRIVATE_DATA *Private; Status = EFI_SUCCESS; Private = AllocateZeroPool (sizeof (PARTITION_PRIVATE_DATA)); if (Private == NULL) { return EFI_OUT_OF_RESOURCES; } Private->Signature = PARTITION_PRIVATE_DATA_SIGNATURE; Private->Start = MultU64x32 (Start, ParentBlockIo->Media->BlockSize); Private->End = MultU64x32 (End + 1, ParentBlockIo->Media->BlockSize); Private->BlockSize = BlockSize; Private->ParentBlockIo = ParentBlockIo; Private->ParentBlockIo2 = ParentBlockIo2; Private->DiskIo = ParentDiskIo; Private->DiskIo2 = ParentDiskIo2; // // Set the BlockIO into Private Data. // Private->BlockIo.Revision = ParentBlockIo->Revision; Private->BlockIo.Media = &Private->Media; CopyMem (Private->BlockIo.Media, ParentBlockIo->Media, sizeof (EFI_BLOCK_IO_MEDIA)); Private->BlockIo.Reset = PartitionReset; Private->BlockIo.ReadBlocks = PartitionReadBlocks; Private->BlockIo.WriteBlocks = PartitionWriteBlocks; Private->BlockIo.FlushBlocks = PartitionFlushBlocks; // // Set the BlockIO2 into Private Data. // if (Private->DiskIo2 != NULL) { ASSERT (Private->ParentBlockIo2 != NULL); Private->BlockIo2.Media = &Private->Media2; CopyMem (Private->BlockIo2.Media, ParentBlockIo2->Media, sizeof (EFI_BLOCK_IO_MEDIA)); Private->BlockIo2.Reset = PartitionResetEx; Private->BlockIo2.ReadBlocksEx = PartitionReadBlocksEx; Private->BlockIo2.WriteBlocksEx = PartitionWriteBlocksEx; Private->BlockIo2.FlushBlocksEx = PartitionFlushBlocksEx; } Private->Media.IoAlign = 0; Private->Media.LogicalPartition = TRUE; Private->Media.LastBlock = DivU64x32 ( MultU64x32 ( End - Start + 1, ParentBlockIo->Media->BlockSize ), BlockSize ) - 1; Private->Media.BlockSize = (UINT32) BlockSize; Private->Media2.IoAlign = 0; Private->Media2.LogicalPartition = TRUE; Private->Media2.LastBlock = Private->Media.LastBlock; Private->Media2.BlockSize = (UINT32) BlockSize; // // Per UEFI Spec, LowestAlignedLba, LogicalBlocksPerPhysicalBlock and OptimalTransferLengthGranularity must be 0 // for logical partitions. // if (Private->BlockIo.Revision >= EFI_BLOCK_IO_PROTOCOL_REVISION2) { Private->Media.LowestAlignedLba = 0; Private->Media.LogicalBlocksPerPhysicalBlock = 0; Private->Media2.LowestAlignedLba = 0; Private->Media2.LogicalBlocksPerPhysicalBlock = 0; if (Private->BlockIo.Revision >= EFI_BLOCK_IO_PROTOCOL_REVISION3) { Private->Media.OptimalTransferLengthGranularity = 0; Private->Media2.OptimalTransferLengthGranularity = 0; } } Private->DevicePath = AppendDevicePathNode (ParentDevicePath, DevicePathNode); if (Private->DevicePath == NULL) { FreePool (Private); return EFI_OUT_OF_RESOURCES; } if (InstallEspGuid) { Private->EspGuid = &gEfiPartTypeSystemPartGuid; } else { // // If NULL InstallMultipleProtocolInterfaces will ignore it. // Private->EspGuid = NULL; } // // Create the new handle. // Private->Handle = NULL; if (Private->DiskIo2 != NULL) { Status = gBS->InstallMultipleProtocolInterfaces ( &Private->Handle, &gEfiDevicePathProtocolGuid, Private->DevicePath, &gEfiBlockIoProtocolGuid, &Private->BlockIo, &gEfiBlockIo2ProtocolGuid, &Private->BlockIo2, Private->EspGuid, NULL, NULL ); } else { Status = gBS->InstallMultipleProtocolInterfaces ( &Private->Handle, &gEfiDevicePathProtocolGuid, Private->DevicePath, &gEfiBlockIoProtocolGuid, &Private->BlockIo, Private->EspGuid, NULL, NULL ); } if (!EFI_ERROR (Status)) { // // Open the Parent Handle for the child // Status = gBS->OpenProtocol ( ParentHandle, &gEfiDiskIoProtocolGuid, (VOID **) &ParentDiskIo, This->DriverBindingHandle, Private->Handle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); } else { FreePool (Private->DevicePath); FreePool (Private); } return Status; }
STATIC EFI_STATUS EFIAPI VirtioNetDriverBindingStart ( IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE DeviceHandle, IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath ) { EFI_STATUS Status; VNET_DEV *Dev; EFI_DEVICE_PATH_PROTOCOL *DevicePath; MAC_ADDR_DEVICE_PATH MacNode; VOID *ChildVirtIo; // // allocate space for the driver instance // Dev = (VNET_DEV *) AllocateZeroPool (sizeof *Dev); if (Dev == NULL) { return EFI_OUT_OF_RESOURCES; } Dev->Signature = VNET_SIG; Status = gBS->OpenProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid, (VOID **)&Dev->VirtIo, This->DriverBindingHandle, DeviceHandle, EFI_OPEN_PROTOCOL_BY_DRIVER); if (EFI_ERROR (Status)) { goto FreeVirtioNet; } // // now we can run a basic one-shot virtio-net initialization required to // retrieve the MAC address // Status = VirtioNetSnpPopulate (Dev); if (EFI_ERROR (Status)) { goto CloseVirtIo; } // // get the device path of the virtio-net device -- one-shot open // Status = gBS->OpenProtocol (DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePath, This->DriverBindingHandle, DeviceHandle, EFI_OPEN_PROTOCOL_GET_PROTOCOL); if (EFI_ERROR (Status)) { goto Evacuate; } // // create another device path that has the MAC address appended // MacNode.Header.Type = MESSAGING_DEVICE_PATH; MacNode.Header.SubType = MSG_MAC_ADDR_DP; SetDevicePathNodeLength (&MacNode, sizeof MacNode); CopyMem (&MacNode.MacAddress, &Dev->Snm.CurrentAddress, sizeof (EFI_MAC_ADDRESS)); MacNode.IfType = Dev->Snm.IfType; Dev->MacDevicePath = AppendDevicePathNode (DevicePath, &MacNode.Header); if (Dev->MacDevicePath == NULL) { Status = EFI_OUT_OF_RESOURCES; goto Evacuate; } // // create a child handle with the Simple Network Protocol and the new // device path installed on it // Status = gBS->InstallMultipleProtocolInterfaces (&Dev->MacHandle, &gEfiSimpleNetworkProtocolGuid, &Dev->Snp, &gEfiDevicePathProtocolGuid, Dev->MacDevicePath, NULL); if (EFI_ERROR (Status)) { goto FreeMacDevicePath; } // // make a note that we keep this device open with VirtIo for the sake of this // child // Status = gBS->OpenProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid, &ChildVirtIo, This->DriverBindingHandle, Dev->MacHandle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER); if (EFI_ERROR (Status)) { goto UninstallMultiple; } return EFI_SUCCESS; UninstallMultiple: gBS->UninstallMultipleProtocolInterfaces (Dev->MacHandle, &gEfiDevicePathProtocolGuid, Dev->MacDevicePath, &gEfiSimpleNetworkProtocolGuid, &Dev->Snp, NULL); FreeMacDevicePath: FreePool (Dev->MacDevicePath); Evacuate: VirtioNetSnpEvacuate (Dev); CloseVirtIo: gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid, This->DriverBindingHandle, DeviceHandle); FreeVirtioNet: FreePool (Dev); return Status; }
/** This function delete and build multi-instance device path for specified type of console device. This function clear the EFI variable defined by ConsoleName and gEfiGlobalVariableGuid. It then build the multi-instance device path by appending the device path of the Console (In/Out/Err) instance in ConsoleMenu. Then it scan all corresponding console device by scanning Terminal (built from device supporting Serial I/O instances) devices in TerminalMenu. At last, it save a EFI variable specifed by ConsoleName and gEfiGlobalVariableGuid. @param ConsoleName The name for the console device type. They are usually "ConIn", "ConOut" and "ErrOut". @param ConsoleMenu The console memu which is a list of console devices. @param UpdatePageId The flag specifying which type of console device to be processed. @retval EFI_SUCCESS The function complete successfully. @return The EFI variable can not be saved. See gRT->SetVariable for detail return information. **/ EFI_STATUS Var_UpdateConsoleOption ( IN UINT16 *ConsoleName, IN BM_MENU_OPTION *ConsoleMenu, IN UINT16 UpdatePageId ) { EFI_DEVICE_PATH_PROTOCOL *ConDevicePath; BM_MENU_ENTRY *NewMenuEntry; BM_CONSOLE_CONTEXT *NewConsoleContext; BM_TERMINAL_CONTEXT *NewTerminalContext; EFI_STATUS Status; VENDOR_DEVICE_PATH Vendor; EFI_DEVICE_PATH_PROTOCOL *TerminalDevicePath; UINTN Index; GetEfiGlobalVariable2 (ConsoleName, (VOID**)&ConDevicePath, NULL); if (ConDevicePath != NULL) { EfiLibDeleteVariable (ConsoleName, &gEfiGlobalVariableGuid); FreePool (ConDevicePath); ConDevicePath = NULL; }; // // First add all console input device from console input menu // for (Index = 0; Index < ConsoleMenu->MenuNumber; Index++) { NewMenuEntry = BOpt_GetMenuEntry (ConsoleMenu, Index); NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext; if (NewConsoleContext->IsActive) { ConDevicePath = AppendDevicePathInstance ( ConDevicePath, NewConsoleContext->DevicePath ); } } for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) { NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index); NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext; if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) || ((NewTerminalContext->IsConOut != 0) && (UpdatePageId == FORM_CON_OUT_ID)) || ((NewTerminalContext->IsStdErr != 0) && (UpdatePageId == FORM_CON_ERR_ID)) ) { Vendor.Header.Type = MESSAGING_DEVICE_PATH; Vendor.Header.SubType = MSG_VENDOR_DP; ASSERT (NewTerminalContext->TerminalType < (sizeof (TerminalTypeGuid) / sizeof (TerminalTypeGuid[0]))); CopyMem ( &Vendor.Guid, &TerminalTypeGuid[NewTerminalContext->TerminalType], sizeof (EFI_GUID) ); SetDevicePathNodeLength (&Vendor.Header, sizeof (VENDOR_DEVICE_PATH)); TerminalDevicePath = AppendDevicePathNode ( NewTerminalContext->DevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &Vendor ); ASSERT (TerminalDevicePath != NULL); ChangeTerminalDevicePath (TerminalDevicePath, TRUE); ConDevicePath = AppendDevicePathInstance ( ConDevicePath, TerminalDevicePath ); } } if (ConDevicePath != NULL) { Status = gRT->SetVariable ( ConsoleName, &gEfiGlobalVariableGuid, VAR_FLAG, GetDevicePathSize (ConDevicePath), ConDevicePath ); if (EFI_ERROR (Status)) { return Status; } } return EFI_SUCCESS; }
/** Scan EMMC Bus to discover the device. @param[in] Private The EMMC driver private data structure. @param[in] Slot The slot number to check device present. @param[in] RemainingDevicePath The pointer to the remaining device path. @retval EFI_SUCCESS Successfully to discover the device and attach SdMmcIoProtocol to it. @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. @retval EFI_ALREADY_STARTED The device was discovered before. @retval Others Fail to discover the device. **/ EFI_STATUS EFIAPI DiscoverEmmcDevice ( IN EMMC_DRIVER_PRIVATE_DATA *Private, IN UINT8 Slot, IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath ) { EFI_STATUS Status; EMMC_DEVICE *Device; EFI_DEVICE_PATH_PROTOCOL *DevicePath; EFI_DEVICE_PATH_PROTOCOL *NewDevicePath; EFI_DEVICE_PATH_PROTOCOL *RemainingEmmcDevPath; EFI_DEV_PATH *Node; EFI_HANDLE DeviceHandle; EFI_SD_MMC_PASS_THRU_PROTOCOL *PassThru; UINT8 Index; Device = NULL; DevicePath = NULL; NewDevicePath = NULL; RemainingDevicePath = NULL; PassThru = Private->PassThru; Device = &Private->Device[Slot]; // // Build Device Path to check if the EMMC device present at the slot. // Status = PassThru->BuildDevicePath ( PassThru, Slot, &DevicePath ); if (EFI_ERROR(Status)) { return Status; } if (DevicePath->SubType != MSG_EMMC_DP) { Status = EFI_UNSUPPORTED; goto Error; } NewDevicePath = AppendDevicePathNode ( Private->ParentDevicePath, DevicePath ); if (NewDevicePath == NULL) { Status = EFI_OUT_OF_RESOURCES; goto Error; } DeviceHandle = NULL; RemainingEmmcDevPath = NewDevicePath; Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &RemainingEmmcDevPath, &DeviceHandle); // // The device path to the EMMC device doesn't exist. It means the corresponding device private data hasn't been initialized. // if (EFI_ERROR (Status) || (DeviceHandle == NULL) || !IsDevicePathEnd (RemainingEmmcDevPath)) { Device->DevicePath = NewDevicePath; Device->Slot = Slot; Device->Private = Private; // // Expose user area in the Sd memory card to upper layer. // Status = DiscoverAllPartitions (Device); if (EFI_ERROR(Status)) { FreePool (NewDevicePath); goto Error; } Status = gBS->InstallProtocolInterface ( &Device->Handle, &gEfiDevicePathProtocolGuid, EFI_NATIVE_INTERFACE, Device->DevicePath ); if (EFI_ERROR(Status)) { FreePool (NewDevicePath); goto Error; } Device->ControllerNameTable = NULL; GetEmmcModelName (Device, &Device->Cid); AddUnicodeString2 ( "eng", gEmmcDxeComponentName.SupportedLanguages, &Device->ControllerNameTable, Device->ModelName, TRUE ); AddUnicodeString2 ( "en", gEmmcDxeComponentName.SupportedLanguages, &Device->ControllerNameTable, Device->ModelName, FALSE ); } if (RemainingDevicePath == NULL) { // // Expose all partitions in the Emmc device to upper layer. // for (Index = 0; Index < EMMC_MAX_PARTITIONS; Index++) { InstallProtocolOnPartition (Device, Index); } } else if (!IsDevicePathEnd (RemainingDevicePath)) { // // Enumerate the specified partition // Node = (EFI_DEV_PATH *) RemainingDevicePath; if ((DevicePathType (&Node->DevPath) != HARDWARE_DEVICE_PATH) || (DevicePathSubType (&Node->DevPath) != HW_CONTROLLER_DP) || (DevicePathNodeLength (&Node->DevPath) != sizeof (CONTROLLER_DEVICE_PATH))) { Status = EFI_INVALID_PARAMETER; goto Error; } Index = (UINT8)Node->Controller.ControllerNumber; if (Index >= EMMC_MAX_PARTITIONS) { Status = EFI_INVALID_PARAMETER; goto Error; } Status = InstallProtocolOnPartition (Device, Index); } Error: FreePool (DevicePath); return Status; }
/** Create the opened instances based on IPv4. @param[in] This Pointer to EFI_DRIVER_BINDING_PROTOCOL. @param[in] ControllerHandle Handle of the child to destroy. @param[in] Private Handle Pointer to PXEBC_PRIVATE_DATA. @retval EFI_SUCCESS The instances based on IPv4 were all created successfully. @retval Others An unexpected error occurred. **/ EFI_STATUS PxeBcCreateIp4Children ( IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE ControllerHandle, IN PXEBC_PRIVATE_DATA *Private ) { EFI_STATUS Status; IPv4_DEVICE_PATH Ip4Node; EFI_PXE_BASE_CODE_MODE *Mode; EFI_UDP4_CONFIG_DATA *Udp4CfgData; EFI_IP4_CONFIG_DATA *Ip4CfgData; EFI_IP4_MODE_DATA Ip4ModeData; PXEBC_PRIVATE_PROTOCOL *Id; EFI_SIMPLE_NETWORK_PROTOCOL *Snp; if (Private->Ip4Nic != NULL) { // // Already created before. // return EFI_SUCCESS; } // // Create Dhcp4 child and open Dhcp4 protocol for PxeBc->Dhcp. // Status = NetLibCreateServiceChild ( ControllerHandle, This->DriverBindingHandle, &gEfiDhcp4ServiceBindingProtocolGuid, &Private->Dhcp4Child ); if (EFI_ERROR (Status)) { goto ON_ERROR; } Status = gBS->OpenProtocol ( Private->Dhcp4Child, &gEfiDhcp4ProtocolGuid, (VOID **) &Private->Dhcp4, This->DriverBindingHandle, ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Create Mtftp4 child and open Mtftp4 protocol for PxeBc->Mtftp. // Status = NetLibCreateServiceChild ( ControllerHandle, This->DriverBindingHandle, &gEfiMtftp4ServiceBindingProtocolGuid, &Private->Mtftp4Child ); if (EFI_ERROR (Status)) { goto ON_ERROR; } Status = gBS->OpenProtocol ( Private->Mtftp4Child, &gEfiMtftp4ProtocolGuid, (VOID **) &Private->Mtftp4, This->DriverBindingHandle, ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Create Udp4 child and open Udp4 protocol for PxeBc->UdpRead. // Status = NetLibCreateServiceChild ( ControllerHandle, This->DriverBindingHandle, &gEfiUdp4ServiceBindingProtocolGuid, &Private->Udp4ReadChild ); if (EFI_ERROR (Status)) { goto ON_ERROR; } Status = gBS->OpenProtocol ( Private->Udp4ReadChild, &gEfiUdp4ProtocolGuid, (VOID **) &Private->Udp4Read, This->DriverBindingHandle, ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Create Udp4 child and open Udp4 protocol for PxeBc->UdpWrite. // Status = NetLibCreateServiceChild ( ControllerHandle, This->DriverBindingHandle, &gEfiUdp4ServiceBindingProtocolGuid, &Private->Udp4WriteChild ); if (EFI_ERROR (Status)) { goto ON_ERROR; } Status = gBS->OpenProtocol ( Private->Udp4WriteChild, &gEfiUdp4ProtocolGuid, (VOID **) &Private->Udp4Write, This->DriverBindingHandle, ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Create Arp child and open Arp protocol for PxeBc->Arp. // Status = NetLibCreateServiceChild ( ControllerHandle, This->DriverBindingHandle, &gEfiArpServiceBindingProtocolGuid, &Private->ArpChild ); if (EFI_ERROR (Status)) { goto ON_ERROR; } Status = gBS->OpenProtocol ( Private->ArpChild, &gEfiArpProtocolGuid, (VOID **) &Private->Arp, This->DriverBindingHandle, ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Create Ip4 child and open Ip4 protocol for background ICMP packets. // Status = NetLibCreateServiceChild ( ControllerHandle, This->DriverBindingHandle, &gEfiIp4ServiceBindingProtocolGuid, &Private->Ip4Child ); if (EFI_ERROR (Status)) { goto ON_ERROR; } Status = gBS->OpenProtocol ( Private->Ip4Child, &gEfiIp4ProtocolGuid, (VOID **) &Private->Ip4, This->DriverBindingHandle, ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Get max packet size from Ip4 to calculate block size for Tftp later. // Status = Private->Ip4->GetModeData (Private->Ip4, &Ip4ModeData, NULL, NULL); if (EFI_ERROR (Status)) { goto ON_ERROR; } Private->Ip4MaxPacketSize = Ip4ModeData.MaxPacketSize; Private->Ip4Nic = AllocateZeroPool (sizeof (PXEBC_VIRTUAL_NIC)); if (Private->Ip4Nic == NULL) { return EFI_OUT_OF_RESOURCES; } Private->Ip4Nic->Private = Private; Private->Ip4Nic->Signature = PXEBC_VIRTUAL_NIC_SIGNATURE; // // Create a device path node for Ipv4 virtual nic, and append it. // ZeroMem (&Ip4Node, sizeof (IPv4_DEVICE_PATH)); Ip4Node.Header.Type = MESSAGING_DEVICE_PATH; Ip4Node.Header.SubType = MSG_IPv4_DP; Ip4Node.StaticIpAddress = FALSE; SetDevicePathNodeLength (&Ip4Node.Header, sizeof (Ip4Node)); Private->Ip4Nic->DevicePath = AppendDevicePathNode (Private->DevicePath, &Ip4Node.Header); if (Private->Ip4Nic->DevicePath == NULL) { Status = EFI_OUT_OF_RESOURCES; goto ON_ERROR; } CopyMem ( &Private->Ip4Nic->LoadFile, &gLoadFileProtocolTemplate, sizeof (EFI_LOAD_FILE_PROTOCOL) ); // // Create a new handle for IPv4 virtual nic, // and install PxeBaseCode, LoadFile and DevicePath protocols. // Status = gBS->InstallMultipleProtocolInterfaces ( &Private->Ip4Nic->Controller, &gEfiDevicePathProtocolGuid, Private->Ip4Nic->DevicePath, &gEfiLoadFileProtocolGuid, &Private->Ip4Nic->LoadFile, &gEfiPxeBaseCodeProtocolGuid, &Private->PxeBc, NULL ); if (EFI_ERROR (Status)) { goto ON_ERROR; } if (Private->Snp != NULL) { // // Install SNP protocol on purpose is for some OS loader backward // compatibility consideration. // Status = gBS->InstallProtocolInterface ( &Private->Ip4Nic->Controller, &gEfiSimpleNetworkProtocolGuid, EFI_NATIVE_INTERFACE, Private->Snp ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Open SNP on the child handle BY_DRIVER. It will prevent any additionally // layering to perform the experiment. // Status = gBS->OpenProtocol ( Private->Ip4Nic->Controller, &gEfiSimpleNetworkProtocolGuid, (VOID **) &Snp, This->DriverBindingHandle, Private->Ip4Nic->Controller, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } } // // Open PxeBaseCodePrivate protocol by child to setup a parent-child relationship between // real NIC handle and the virtual IPv4 NIC handle. // Status = gBS->OpenProtocol ( ControllerHandle, &gEfiCallerIdGuid, (VOID **) &Id, This->DriverBindingHandle, Private->Ip4Nic->Controller, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Set default configure data for Udp4Read and Ip4 instance. // Mode = Private->PxeBc.Mode; Udp4CfgData = &Private->Udp4CfgData; Ip4CfgData = &Private->Ip4CfgData; Udp4CfgData->AcceptBroadcast = FALSE; Udp4CfgData->AcceptAnyPort = TRUE; Udp4CfgData->AllowDuplicatePort = TRUE; Udp4CfgData->TypeOfService = Mode->ToS; Udp4CfgData->TimeToLive = Mode->TTL; Udp4CfgData->ReceiveTimeout = PXEBC_DEFAULT_LIFETIME; Udp4CfgData->TransmitTimeout = PXEBC_DEFAULT_LIFETIME; Ip4CfgData->AcceptIcmpErrors = TRUE; Ip4CfgData->DefaultProtocol = EFI_IP_PROTO_ICMP; Ip4CfgData->TypeOfService = Mode->ToS; Ip4CfgData->TimeToLive = Mode->TTL; Ip4CfgData->ReceiveTimeout = PXEBC_DEFAULT_LIFETIME; Ip4CfgData->TransmitTimeout = PXEBC_DEFAULT_LIFETIME; return EFI_SUCCESS; ON_ERROR: PxeBcDestroyIp4Children (This, Private); return Status; }
EFI_STATUS PrepareLpcBridgeDevicePath ( IN EFI_HANDLE DeviceHandle ) /*++ Routine Description: Add IsaKeyboard to ConIn, add IsaSerial to ConOut, ConIn, ErrOut. LPC Bridge: 06 01 00 Arguments: DeviceHandle - Handle of PCIIO protocol. Returns: EFI_SUCCESS - LPC bridge is added to ConOut, ConIn, and ErrOut. EFI_STATUS - No LPC bridge is added. --*/ { EFI_STATUS Status; EFI_DEVICE_PATH_PROTOCOL *DevicePath; EFI_DEVICE_PATH_PROTOCOL *TempDevicePath; CHAR16 *DevPathStr; DevicePath = NULL; Status = gBS->HandleProtocol ( DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID*)&DevicePath ); if (EFI_ERROR (Status)) { return Status; } TempDevicePath = DevicePath; // // Register Keyboard // DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gPnpPs2KeyboardDeviceNode); BdsLibUpdateConsoleVariable (VarConsoleInp, DevicePath, NULL); // // Register COM1 // DevicePath = TempDevicePath; gPnp16550ComPortDeviceNode.UID = 0; DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gPnp16550ComPortDeviceNode); DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gUartDeviceNode); DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gTerminalTypeDeviceNode); // // Print Device Path // DevPathStr = DevicePathToStr(DevicePath); if (DevPathStr != NULL) { DEBUG(( EFI_D_INFO, "BdsPlatform.c+%d: COM%d DevPath: %s\n", __LINE__, gPnp16550ComPortDeviceNode.UID + 1, DevPathStr )); FreePool(DevPathStr); } BdsLibUpdateConsoleVariable (VarConsoleOut, DevicePath, NULL); BdsLibUpdateConsoleVariable (VarConsoleInp, DevicePath, NULL); BdsLibUpdateConsoleVariable (VarErrorOut, DevicePath, NULL); // // Register COM2 // DevicePath = TempDevicePath; gPnp16550ComPortDeviceNode.UID = 1; DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gPnp16550ComPortDeviceNode); DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gUartDeviceNode); DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gTerminalTypeDeviceNode); // // Print Device Path // DevPathStr = DevicePathToStr(DevicePath); if (DevPathStr != NULL) { DEBUG(( EFI_D_INFO, "BdsPlatform.c+%d: COM%d DevPath: %s\n", __LINE__, gPnp16550ComPortDeviceNode.UID + 1, DevPathStr )); FreePool(DevPathStr); } BdsLibUpdateConsoleVariable (VarConsoleOut, DevicePath, NULL); BdsLibUpdateConsoleVariable (VarConsoleInp, DevicePath, NULL); BdsLibUpdateConsoleVariable (VarErrorOut, DevicePath, NULL); return EFI_SUCCESS; }
/** Create an interface for the descriptor IfDesc. Each device's configuration can have several interfaces. @param Device The device has the interface descriptor. @param IfDesc The interface descriptor. @return The created USB interface for the descriptor, or NULL. **/ USB_INTERFACE * UsbCreateInterface ( IN USB_DEVICE *Device, IN USB_INTERFACE_DESC *IfDesc ) { USB_DEVICE_PATH UsbNode; USB_INTERFACE *UsbIf; USB_INTERFACE *HubIf; EFI_STATUS Status; UsbIf = AllocateZeroPool (sizeof (USB_INTERFACE)); if (UsbIf == NULL) { return NULL; } UsbIf->Signature = USB_INTERFACE_SIGNATURE; UsbIf->Device = Device; UsbIf->IfDesc = IfDesc; // ASSERT (IfDesc->ActiveIndex < USB_MAX_INTERFACE_SETTING); if (IfDesc->ActiveIndex >= USB_MAX_INTERFACE_SETTING) { FreePool(UsbIf); return NULL; } UsbIf->IfSetting = IfDesc->Settings[IfDesc->ActiveIndex]; CopyMem ( &(UsbIf->UsbIo), &mUsbIoProtocol, sizeof (EFI_USB_IO_PROTOCOL) ); // // Install protocols for USBIO and device path // UsbNode.Header.Type = MESSAGING_DEVICE_PATH; UsbNode.Header.SubType = MSG_USB_DP; UsbNode.ParentPortNumber = Device->ParentPort; UsbNode.InterfaceNumber = UsbIf->IfSetting->Desc.InterfaceNumber; SetDevicePathNodeLength (&UsbNode.Header, sizeof (UsbNode)); HubIf = Device->ParentIf; // ASSERT (HubIf != NULL); if (!HubIf) { return NULL; } UsbIf->DevicePath = AppendDevicePathNode (HubIf->DevicePath, &UsbNode.Header); if (UsbIf->DevicePath == NULL) { // DEBUG ((EFI_D_ERROR, "UsbCreateInterface: failed to create device path\n")); DBG("UsbCreateInterface: failed to create device path\n"); Status = EFI_OUT_OF_RESOURCES; goto ON_ERROR; } Status = gBS->InstallMultipleProtocolInterfaces ( &UsbIf->Handle, &gEfiDevicePathProtocolGuid, UsbIf->DevicePath, &gEfiUsbIoProtocolGuid, &UsbIf->UsbIo, NULL ); if (EFI_ERROR (Status)) { // DEBUG ((EFI_D_ERROR, "UsbCreateInterface: failed to install UsbIo - %r\n", Status)); goto ON_ERROR; } // // Open USB Host Controller Protocol by Child // Status = UsbOpenHostProtoByChild (Device->Bus, UsbIf->Handle); if (EFI_ERROR (Status)) { gBS->UninstallMultipleProtocolInterfaces ( &UsbIf->Handle, &gEfiDevicePathProtocolGuid, UsbIf->DevicePath, &gEfiUsbIoProtocolGuid, &UsbIf->UsbIo, NULL ); // DEBUG ((EFI_D_ERROR, "UsbCreateInterface: failed to open host for child - %r\n", Status)); DBG("UsbCreateInterface: failed to open host for child - %r\n", Status); goto ON_ERROR; } return UsbIf; ON_ERROR: if (UsbIf->DevicePath != NULL) { FreePool (UsbIf->DevicePath); } FreePool (UsbIf); return NULL; }
/** Install HII Config Access protocol for network device and allocate resource. @param[in] Instance The IP4 Config instance. @retval EFI_SUCCESS The HII Config Access protocol is installed. @retval EFI_OUT_OF_RESOURCES Failed to allocate memory. @retval Others Other errors as indicated. **/ EFI_STATUS Ip4ConfigDeviceInit ( IN IP4_CONFIG_INSTANCE *Instance ) { EFI_STATUS Status; EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess; VENDOR_DEVICE_PATH VendorDeviceNode; EFI_SERVICE_BINDING_PROTOCOL *MnpSb; CHAR16 *MacString; CHAR16 MenuString[128]; CHAR16 PortString[128]; CHAR16 *OldMenuString; ConfigAccess = &Instance->HiiConfigAccessProtocol; ConfigAccess->ExtractConfig = Ip4DeviceExtractConfig; ConfigAccess->RouteConfig = Ip4DeviceRouteConfig; ConfigAccess->Callback = Ip4FormCallback; // // Construct device path node for EFI HII Config Access protocol, // which consists of controller physical device path and one hardware // vendor guid node. // ZeroMem (&VendorDeviceNode, sizeof (VENDOR_DEVICE_PATH)); VendorDeviceNode.Header.Type = HARDWARE_DEVICE_PATH; VendorDeviceNode.Header.SubType = HW_VENDOR_DP; CopyGuid (&VendorDeviceNode.Guid, &gEfiNicIp4ConfigVariableGuid); SetDevicePathNodeLength (&VendorDeviceNode.Header, sizeof (VENDOR_DEVICE_PATH)); Instance->HiiVendorDevicePath = AppendDevicePathNode ( Instance->ParentDevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &VendorDeviceNode ); Instance->ChildHandle = NULL; // // Install Device Path Protocol and Config Access protocol on new handle // Status = gBS->InstallMultipleProtocolInterfaces ( &Instance->ChildHandle, &gEfiDevicePathProtocolGuid, Instance->HiiVendorDevicePath, &gEfiHiiConfigAccessProtocolGuid, ConfigAccess, NULL ); if (!EFI_ERROR (Status)) { // // Open the Parent Handle for the child // Status = gBS->OpenProtocol ( Instance->Controller, &gEfiManagedNetworkServiceBindingProtocolGuid, (VOID **) &MnpSb, Instance->Image, Instance->ChildHandle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); } ASSERT_EFI_ERROR (Status); // // Publish our HII data // Instance->RegisteredHandle = HiiAddPackages ( &mNicIp4ConfigNvDataGuid, Instance->ChildHandle, Ip4ConfigDxeStrings, Ip4ConfigDxeBin, NULL ); if (Instance->RegisteredHandle == NULL) { return EFI_OUT_OF_RESOURCES; } // // Append MAC string in the menu string and tile string // Status = NetLibGetMacString (Instance->Controller, Instance->Image, &MacString); if (!EFI_ERROR (Status)) { OldMenuString = HiiGetString (Instance->RegisteredHandle, STRING_TOKEN (STR_IP4_CONFIG_FORM_TITLE), NULL); UnicodeSPrint (MenuString, 128, L"%s (MAC:%s)", OldMenuString, MacString); HiiSetString (Instance->RegisteredHandle, STRING_TOKEN (STR_IP4_CONFIG_FORM_TITLE), MenuString, NULL); UnicodeSPrint (PortString, 128, L"MAC:%s", MacString); HiiSetString (Instance->RegisteredHandle, STRING_TOKEN (STR_IP4_DEVICE_FORM_TITLE), PortString, NULL); FreePool (MacString); } return Status; }
/** Binds exclusively to serial io on the controller handle, Produces DebugPort protocol and DevicePath on new handle. @param This Protocol instance pointer. @param ControllerHandle Handle of device to bind driver to. @param RemainingDevicePath Optional parameter use to pick a specific child device to start. @retval EFI_SUCCESS This driver is added to ControllerHandle. @retval EFI_OUT_OF_RESOURCES Fails to allocate memory for device. @retval others Some error occurs. **/ EFI_STATUS EFIAPI DebugPortStart ( IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE ControllerHandle, IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath ) { EFI_STATUS Status; DEBUGPORT_DEVICE_PATH DebugPortDP; EFI_DEVICE_PATH_PROTOCOL EndDP; EFI_DEVICE_PATH_PROTOCOL *Dp1; Status = gBS->OpenProtocol ( ControllerHandle, &gEfiSerialIoProtocolGuid, (VOID **) &mDebugPortDevice.SerialIoBinding, This->DriverBindingHandle, ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE ); if (EFI_ERROR (Status)) { return Status; } mDebugPortDevice.SerialIoDeviceHandle = ControllerHandle; // // Initialize the Serial Io interface... // Status = mDebugPortDevice.SerialIoBinding->SetAttributes ( mDebugPortDevice.SerialIoBinding, mDebugPortDevice.BaudRate, mDebugPortDevice.ReceiveFifoDepth, mDebugPortDevice.Timeout, mDebugPortDevice.Parity, mDebugPortDevice.DataBits, mDebugPortDevice.StopBits ); if (EFI_ERROR (Status)) { mDebugPortDevice.BaudRate = 0; mDebugPortDevice.Parity = DefaultParity; mDebugPortDevice.DataBits = 0; mDebugPortDevice.StopBits = DefaultStopBits; mDebugPortDevice.ReceiveFifoDepth = 0; Status = mDebugPortDevice.SerialIoBinding->SetAttributes ( mDebugPortDevice.SerialIoBinding, mDebugPortDevice.BaudRate, mDebugPortDevice.ReceiveFifoDepth, mDebugPortDevice.Timeout, mDebugPortDevice.Parity, mDebugPortDevice.DataBits, mDebugPortDevice.StopBits ); if (EFI_ERROR (Status)) { gBS->CloseProtocol ( ControllerHandle, &gEfiSerialIoProtocolGuid, This->DriverBindingHandle, ControllerHandle ); return Status; } } mDebugPortDevice.SerialIoBinding->Reset (mDebugPortDevice.SerialIoBinding); // // Create device path instance for DebugPort // DebugPortDP.Header.Type = MESSAGING_DEVICE_PATH; DebugPortDP.Header.SubType = MSG_VENDOR_DP; SetDevicePathNodeLength (&(DebugPortDP.Header), sizeof (DebugPortDP)); CopyGuid (&DebugPortDP.Guid, &gEfiDebugPortDevicePathGuid); Dp1 = DevicePathFromHandle (ControllerHandle); if (Dp1 == NULL) { Dp1 = &EndDP; SetDevicePathEndNode (Dp1); } mDebugPortDevice.DebugPortDevicePath = AppendDevicePathNode (Dp1, (EFI_DEVICE_PATH_PROTOCOL *) &DebugPortDP); if (mDebugPortDevice.DebugPortDevicePath == NULL) { return EFI_OUT_OF_RESOURCES; } // // Publish DebugPort and Device Path protocols // Status = gBS->InstallMultipleProtocolInterfaces ( &mDebugPortDevice.DebugPortDeviceHandle, &gEfiDevicePathProtocolGuid, mDebugPortDevice.DebugPortDevicePath, &gEfiDebugPortProtocolGuid, &mDebugPortDevice.DebugPortInterface, NULL ); if (EFI_ERROR (Status)) { gBS->CloseProtocol ( ControllerHandle, &gEfiSerialIoProtocolGuid, This->DriverBindingHandle, ControllerHandle ); return Status; } // // Connect debugport child to serial io // Status = gBS->OpenProtocol ( ControllerHandle, &gEfiSerialIoProtocolGuid, (VOID **) &mDebugPortDevice.SerialIoBinding, This->DriverBindingHandle, mDebugPortDevice.DebugPortDeviceHandle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); if (EFI_ERROR (Status)) { gBS->CloseProtocol ( ControllerHandle, &gEfiSerialIoProtocolGuid, This->DriverBindingHandle, ControllerHandle ); return Status; } return EFI_SUCCESS; }
/** Build device path for EDD 3.0. @param BaseDevicePath Base device path. @param Drive Legacy drive. @param DevicePath Device path for output. @retval EFI_SUCCESS The device path is built successfully. @retval EFI_UNSUPPORTED It is failed to built device path. **/ EFI_STATUS BuildEdd30DevicePath ( IN EFI_DEVICE_PATH_PROTOCOL *BaseDevicePath, IN BIOS_LEGACY_DRIVE *Drive, IN EFI_DEVICE_PATH_PROTOCOL **DevicePath ) { // // AVL UINT64 Address; // AVL EFI_HANDLE Handle; // EFI_DEV_PATH Node; UINT32 Controller; Controller = (UINT32) Drive->Parameters.InterfacePath.Pci.Controller; ZeroMem (&Node, sizeof (Node)); if ((AsciiStrnCmp ("ATAPI", Drive->Parameters.InterfaceType, 5) == 0) || (AsciiStrnCmp ("ATA", Drive->Parameters.InterfaceType, 3) == 0) ) { // // ATA or ATAPI drive found // Node.Atapi.Header.Type = MESSAGING_DEVICE_PATH; Node.Atapi.Header.SubType = MSG_ATAPI_DP; SetDevicePathNodeLength (&Node.Atapi.Header, sizeof (ATAPI_DEVICE_PATH)); Node.Atapi.SlaveMaster = Drive->Parameters.DevicePath.Atapi.Master; Node.Atapi.Lun = Drive->Parameters.DevicePath.Atapi.Lun; Node.Atapi.PrimarySecondary = (UINT8) Controller; } else { // // Not an ATA/ATAPI drive // #if 0 if (Controller != 0) { ZeroMem (&Node, sizeof (Node)); Node.Controller.Header.Type = HARDWARE_DEVICE_PATH; Node.Controller.Header.SubType = HW_CONTROLLER_DP; SetDevicePathNodeLength (&Node.Controller.Header, sizeof (CONTROLLER_DEVICE_PATH)); Node.Controller.ControllerNumber = Controller; *DevicePath = AppendDevicePathNode (*DevicePath, &Node.DevPath); } ZeroMem (&Node, sizeof (Node)); #endif if (AsciiStrnCmp ("SCSI", Drive->Parameters.InterfaceType, 4) == 0) { // // SCSI drive // Node.Scsi.Header.Type = MESSAGING_DEVICE_PATH; Node.Scsi.Header.SubType = MSG_SCSI_DP; SetDevicePathNodeLength (&Node.Scsi.Header, sizeof (SCSI_DEVICE_PATH)); // // Lun is miss aligned in both EDD and Device Path data structures. // thus we do a byte copy, to prevent alignment traps on IA-64. // CopyMem (&Node.Scsi.Lun, &Drive->Parameters.DevicePath.Scsi.Lun, sizeof (UINT16)); Node.Scsi.Pun = Drive->Parameters.DevicePath.Scsi.Pun; } else if (AsciiStrnCmp ("USB", Drive->Parameters.InterfaceType, 3) == 0) { // // USB drive // Node.Usb.Header.Type = MESSAGING_DEVICE_PATH; Node.Usb.Header.SubType = MSG_USB_DP; SetDevicePathNodeLength (&Node.Usb.Header, sizeof (USB_DEVICE_PATH)); Node.Usb.ParentPortNumber = Drive->Number; //(UINT8) Drive->Parameters.DevicePath.Usb.Reserved; Node.Usb.InterfaceNumber = (UINT8) Drive->Parameters.DevicePath.Usb.SerialNumber; } else if (AsciiStrnCmp ("1394", Drive->Parameters.InterfaceType, 4) == 0) { // // 1394 drive // Node.F1394.Header.Type = MESSAGING_DEVICE_PATH; Node.F1394.Header.SubType = MSG_1394_DP; SetDevicePathNodeLength (&Node.F1394.Header, sizeof (F1394_DEVICE_PATH)); Node.F1394.Guid = Drive->Parameters.DevicePath.FireWire.Guid; } else if (AsciiStrnCmp ("FIBRE", Drive->Parameters.InterfaceType, 5) == 0) { // // Fibre drive // Node.FibreChannel.Header.Type = MESSAGING_DEVICE_PATH; Node.FibreChannel.Header.SubType = MSG_FIBRECHANNEL_DP; SetDevicePathNodeLength (&Node.FibreChannel.Header, sizeof (FIBRECHANNEL_DEVICE_PATH)); Node.FibreChannel.WWN = Drive->Parameters.DevicePath.FibreChannel.Wwn; Node.FibreChannel.Lun = Drive->Parameters.DevicePath.FibreChannel.Lun; } else { DEBUG ( ( DEBUG_BLKIO, "It is unrecognized EDD 3.0 device, Drive Number = %x, InterfaceType = %s\n", Drive->Number, Drive->Parameters.InterfaceType ) ); } } if (Node.DevPath.Type == 0) { return EFI_UNSUPPORTED; } *DevicePath = AppendDevicePathNode (BaseDevicePath, &Node.DevPath); return EFI_SUCCESS; }
/** Install HII Config Access protocol for network device and allocate resource. @param[in, out] Instance The IP4 config2 Instance. @retval EFI_SUCCESS The HII Config Access protocol is installed. @retval EFI_OUT_OF_RESOURCES Failed to allocate memory. @retval Others Other errors as indicated. **/ EFI_STATUS Ip4Config2FormInit ( IN OUT IP4_CONFIG2_INSTANCE *Instance ) { EFI_STATUS Status; IP4_SERVICE *IpSb; IP4_FORM_CALLBACK_INFO *CallbackInfo; EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess; VENDOR_DEVICE_PATH VendorDeviceNode; EFI_SERVICE_BINDING_PROTOCOL *MnpSb; CHAR16 *MacString; CHAR16 MenuString[128]; CHAR16 PortString[128]; CHAR16 *OldMenuString; EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance); ASSERT (IpSb != NULL); CallbackInfo = &Instance->CallbackInfo; CallbackInfo->Signature = IP4_FORM_CALLBACK_INFO_SIGNATURE; Status = gBS->HandleProtocol ( IpSb->Controller, &gEfiDevicePathProtocolGuid, (VOID **) &ParentDevicePath ); if (EFI_ERROR (Status)) { return Status; } // // Construct device path node for EFI HII Config Access protocol, // which consists of controller physical device path and one hardware // vendor guid node. // ZeroMem (&VendorDeviceNode, sizeof (VENDOR_DEVICE_PATH)); VendorDeviceNode.Header.Type = HARDWARE_DEVICE_PATH; VendorDeviceNode.Header.SubType = HW_VENDOR_DP; CopyGuid (&VendorDeviceNode.Guid, &gEfiCallerIdGuid); SetDevicePathNodeLength (&VendorDeviceNode.Header, sizeof (VENDOR_DEVICE_PATH)); CallbackInfo->HiiVendorDevicePath = AppendDevicePathNode ( ParentDevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &VendorDeviceNode ); if (CallbackInfo->HiiVendorDevicePath == NULL) { Status = EFI_OUT_OF_RESOURCES; goto Error; } ConfigAccess = &CallbackInfo->HiiConfigAccessProtocol; ConfigAccess->ExtractConfig = Ip4FormExtractConfig; ConfigAccess->RouteConfig = Ip4FormRouteConfig; ConfigAccess->Callback = Ip4FormCallback; // // Install Device Path Protocol and Config Access protocol on new handle // Status = gBS->InstallMultipleProtocolInterfaces ( &CallbackInfo->ChildHandle, &gEfiDevicePathProtocolGuid, CallbackInfo->HiiVendorDevicePath, &gEfiHiiConfigAccessProtocolGuid, ConfigAccess, NULL ); if (!EFI_ERROR (Status)) { // // Open the Parent Handle for the child // Status = gBS->OpenProtocol ( IpSb->Controller, &gEfiManagedNetworkServiceBindingProtocolGuid, (VOID **) &MnpSb, IpSb->Image, CallbackInfo->ChildHandle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); } if (EFI_ERROR (Status)) { goto Error; } // // Publish our HII data // CallbackInfo->RegisteredHandle = HiiAddPackages ( &gIp4Config2NvDataGuid, CallbackInfo->ChildHandle, Ip4DxeStrings, Ip4Config2Bin, NULL ); if (CallbackInfo->RegisteredHandle == NULL) { Status = EFI_OUT_OF_RESOURCES; goto Error; } // // Append MAC string in the menu help string and tile help string // Status = NetLibGetMacString (IpSb->Controller, IpSb->Image, &MacString); if (!EFI_ERROR (Status)) { OldMenuString = HiiGetString ( CallbackInfo->RegisteredHandle, STRING_TOKEN (STR_IP4_CONFIG2_FORM_HELP), NULL ); UnicodeSPrint (MenuString, 128, L"%s (MAC:%s)", OldMenuString, MacString); HiiSetString ( CallbackInfo->RegisteredHandle, STRING_TOKEN (STR_IP4_CONFIG2_FORM_HELP), MenuString, NULL ); UnicodeSPrint (PortString, 128, L"MAC:%s", MacString); HiiSetString ( CallbackInfo->RegisteredHandle, STRING_TOKEN (STR_IP4_DEVICE_FORM_HELP), PortString, NULL ); FreePool (MacString); FreePool (OldMenuString); return EFI_SUCCESS; } Error: Ip4Config2FormUnload (Instance); return Status; }
/** This function publish the VLAN configuration Form for a network device. The HII Config Access protocol will be installed on a child handle of the network device. @param[in, out] PrivateData Points to VLAN configuration private data. @retval EFI_SUCCESS HII Form is installed for this network device. @retval EFI_OUT_OF_RESOURCES Not enough resource for HII Form installation. @retval Others Other errors as indicated. **/ EFI_STATUS InstallVlanConfigForm ( IN OUT VLAN_CONFIG_PRIVATE_DATA *PrivateData ) { EFI_STATUS Status; EFI_HII_HANDLE HiiHandle; EFI_HANDLE DriverHandle; CHAR16 Str[26 + sizeof (EFI_MAC_ADDRESS) * 2 + 1]; CHAR16 *MacString; EFI_DEVICE_PATH_PROTOCOL *ChildDevicePath; EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess; EFI_VLAN_CONFIG_PROTOCOL *VlanConfig; // // Create child handle and install HII Config Access Protocol // ChildDevicePath = AppendDevicePathNode ( PrivateData->ParentDevicePath, (CONST EFI_DEVICE_PATH_PROTOCOL *) &mHiiVendorDevicePathNode ); if (ChildDevicePath == NULL) { return EFI_OUT_OF_RESOURCES; } PrivateData->ChildDevicePath = ChildDevicePath; DriverHandle = NULL; ConfigAccess = &PrivateData->ConfigAccess; Status = gBS->InstallMultipleProtocolInterfaces ( &DriverHandle, &gEfiDevicePathProtocolGuid, ChildDevicePath, &gEfiHiiConfigAccessProtocolGuid, ConfigAccess, NULL ); if (EFI_ERROR (Status)) { return Status; } PrivateData->DriverHandle = DriverHandle; // // Establish the parent-child relationship between the new created // child handle and the ControllerHandle. // Status = gBS->OpenProtocol ( PrivateData->ControllerHandle, &gEfiVlanConfigProtocolGuid, (VOID **)&VlanConfig, PrivateData->ImageHandle, PrivateData->DriverHandle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); if (EFI_ERROR (Status)) { return Status; } // // Publish the HII package list // HiiHandle = HiiAddPackages ( &gVlanConfigFormSetGuid, DriverHandle, VlanConfigDxeStrings, VlanConfigBin, NULL ); if (HiiHandle == NULL) { return EFI_OUT_OF_RESOURCES; } PrivateData->HiiHandle = HiiHandle; // // Update formset title help string. // MacString = NULL; Status = NetLibGetMacString (PrivateData->ControllerHandle, PrivateData->ImageHandle, &MacString); if (EFI_ERROR (Status)) { return Status; } PrivateData->MacString = MacString; StrCpy (Str, L"VLAN Configuration (MAC:"); StrnCat (Str, MacString, sizeof (EFI_MAC_ADDRESS) * 2); StrCat (Str, L")"); HiiSetString ( HiiHandle, STRING_TOKEN (STR_VLAN_FORM_SET_TITLE_HELP), Str, NULL ); // // Update form title help string. // HiiSetString ( HiiHandle, STRING_TOKEN (STR_VLAN_FORM_HELP), Str, NULL ); return EFI_SUCCESS; }
/** Scan SCSI Bus to discover the device, and attach ScsiIoProtocol to it. @param This Protocol instance pointer @param Controller Controller handle @param TargetId Tartget to be scanned @param Lun The Lun of the SCSI device on the SCSI channel. @param ScsiBusDev The pointer of SCSI_BUS_DEVICE @retval EFI_SUCCESS Successfully to discover the device and attach ScsiIoProtocol to it. @retval EFI_OUT_OF_RESOURCES Fail to discover the device. **/ EFI_STATUS EFIAPI ScsiScanCreateDevice ( IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE Controller, IN SCSI_TARGET_ID *TargetId, IN UINT64 Lun, IN OUT SCSI_BUS_DEVICE *ScsiBusDev ) { EFI_STATUS Status; SCSI_IO_DEV *ScsiIoDevice; EFI_DEVICE_PATH_PROTOCOL *ScsiDevicePath; EFI_DEVICE_PATH_PROTOCOL *DevicePath; EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath; EFI_HANDLE DeviceHandle; DevicePath = NULL; RemainingDevicePath = NULL; ScsiDevicePath = NULL; ScsiIoDevice = NULL; // // Build Device Path // if (ScsiBusDev->ExtScsiSupport){ Status = ScsiBusDev->ExtScsiInterface->BuildDevicePath ( ScsiBusDev->ExtScsiInterface, &TargetId->ScsiId.ExtScsi[0], Lun, &ScsiDevicePath ); } else { Status = ScsiBusDev->ScsiInterface->BuildDevicePath ( ScsiBusDev->ScsiInterface, TargetId->ScsiId.Scsi, Lun, &ScsiDevicePath ); } if (EFI_ERROR(Status)) { return Status; } DevicePath = AppendDevicePathNode ( ScsiBusDev->DevicePath, ScsiDevicePath ); if (DevicePath == NULL) { Status = EFI_OUT_OF_RESOURCES; goto ErrorExit; } DeviceHandle = NULL; RemainingDevicePath = DevicePath; Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &RemainingDevicePath, &DeviceHandle); if (!EFI_ERROR (Status) && (DeviceHandle != NULL) && IsDevicePathEnd(RemainingDevicePath)) { // // The device has been started, directly return to fast boot. // Status = EFI_ALREADY_STARTED; goto ErrorExit; } ScsiIoDevice = AllocateZeroPool (sizeof (SCSI_IO_DEV)); if (ScsiIoDevice == NULL) { Status = EFI_OUT_OF_RESOURCES; goto ErrorExit; } ScsiIoDevice->Signature = SCSI_IO_DEV_SIGNATURE; CopyMem(&ScsiIoDevice->Pun, TargetId, TARGET_MAX_BYTES); ScsiIoDevice->Lun = Lun; if (ScsiBusDev->ExtScsiSupport) { ScsiIoDevice->ExtScsiPassThru = ScsiBusDev->ExtScsiInterface; ScsiIoDevice->ExtScsiSupport = TRUE; ScsiIoDevice->ScsiIo.IoAlign = ScsiIoDevice->ExtScsiPassThru->Mode->IoAlign; } else { ScsiIoDevice->ScsiPassThru = ScsiBusDev->ScsiInterface; ScsiIoDevice->ExtScsiSupport = FALSE; ScsiIoDevice->ScsiIo.IoAlign = ScsiIoDevice->ScsiPassThru->Mode->IoAlign; } ScsiIoDevice->ScsiIo.GetDeviceType = ScsiGetDeviceType; ScsiIoDevice->ScsiIo.GetDeviceLocation = ScsiGetDeviceLocation; ScsiIoDevice->ScsiIo.ResetBus = ScsiResetBus; ScsiIoDevice->ScsiIo.ResetDevice = ScsiResetDevice; ScsiIoDevice->ScsiIo.ExecuteScsiCommand = ScsiExecuteSCSICommand; if (!DiscoverScsiDevice (ScsiIoDevice)) { Status = EFI_OUT_OF_RESOURCES; goto ErrorExit; } ScsiIoDevice->DevicePath = DevicePath; Status = gBS->InstallMultipleProtocolInterfaces ( &ScsiIoDevice->Handle, &gEfiDevicePathProtocolGuid, ScsiIoDevice->DevicePath, &gEfiScsiIoProtocolGuid, &ScsiIoDevice->ScsiIo, NULL ); if (EFI_ERROR (Status)) { goto ErrorExit; } else { if (ScsiBusDev->ExtScsiSupport) { gBS->OpenProtocol ( Controller, &gEfiExtScsiPassThruProtocolGuid, (VOID **) &(ScsiBusDev->ExtScsiInterface), This->DriverBindingHandle, ScsiIoDevice->Handle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); } else { gBS->OpenProtocol ( Controller, &gEfiScsiPassThruProtocolGuid, (VOID **) &(ScsiBusDev->ScsiInterface), This->DriverBindingHandle, ScsiIoDevice->Handle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); } } return EFI_SUCCESS; ErrorExit: // // The memory space for ScsiDevicePath is allocated in // ScsiPassThru->BuildDevicePath() function; It is no longer used // after AppendDevicePathNode,so free the memory it occupies. // FreePool (ScsiDevicePath); if (DevicePath != NULL) { FreePool (DevicePath); } if (ScsiIoDevice != NULL) { FreePool (ScsiIoDevice); } return Status; }
/** Create the opened instances based on IPv6. @param[in] This Pointer to EFI_DRIVER_BINDING_PROTOCOL. @param[in] ControllerHandle Handle of the child to destroy. @param[in] Private Handle Pointer to PXEBC_PRIVATE_DATA. @retval EFI_SUCCESS The instances based on IPv6 were all created successfully. @retval Others An unexpected error occurred. **/ EFI_STATUS PxeBcCreateIp6Children ( IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE ControllerHandle, IN PXEBC_PRIVATE_DATA *Private ) { EFI_STATUS Status; IPv6_DEVICE_PATH Ip6Node; EFI_UDP6_CONFIG_DATA *Udp6CfgData; EFI_IP6_CONFIG_DATA *Ip6CfgData; EFI_IP6_MODE_DATA Ip6ModeData; PXEBC_PRIVATE_PROTOCOL *Id; EFI_SIMPLE_NETWORK_PROTOCOL *Snp; UINTN Index; if (Private->Ip6Nic != NULL) { // // Already created before. // return EFI_SUCCESS; } Private->Ip6Nic = AllocateZeroPool (sizeof (PXEBC_VIRTUAL_NIC)); if (Private->Ip6Nic == NULL) { return EFI_OUT_OF_RESOURCES; } Private->Ip6Nic->Private = Private; Private->Ip6Nic->Signature = PXEBC_VIRTUAL_NIC_SIGNATURE; // // Create Dhcp6 child and open Dhcp6 protocol for PxeBc->Dhcp. // Status = NetLibCreateServiceChild ( ControllerHandle, This->DriverBindingHandle, &gEfiDhcp6ServiceBindingProtocolGuid, &Private->Dhcp6Child ); if (EFI_ERROR (Status)) { goto ON_ERROR; } Status = gBS->OpenProtocol ( Private->Dhcp6Child, &gEfiDhcp6ProtocolGuid, (VOID **) &Private->Dhcp6, This->DriverBindingHandle, ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Generate a random IAID for the Dhcp6 assigned address. // Private->IaId = NET_RANDOM (NetRandomInitSeed ()); if (Private->Snp != NULL) { for (Index = 0; Index < Private->Snp->Mode->HwAddressSize; Index++) { Private->IaId |= (Private->Snp->Mode->CurrentAddress.Addr[Index] << ((Index << 3) & 31)); } } // // Create Mtftp6 child and open Mtftp6 protocol for PxeBc->Mtftp. // Status = NetLibCreateServiceChild ( ControllerHandle, This->DriverBindingHandle, &gEfiMtftp6ServiceBindingProtocolGuid, &Private->Mtftp6Child ); if (EFI_ERROR (Status)) { goto ON_ERROR; } Status = gBS->OpenProtocol ( Private->Mtftp6Child, &gEfiMtftp6ProtocolGuid, (VOID **) &Private->Mtftp6, This->DriverBindingHandle, ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Create Udp6 child and open Udp6 protocol for PxeBc->UdpRead. // Status = NetLibCreateServiceChild ( ControllerHandle, This->DriverBindingHandle, &gEfiUdp6ServiceBindingProtocolGuid, &Private->Udp6ReadChild ); if (EFI_ERROR (Status)) { goto ON_ERROR; } Status = gBS->OpenProtocol ( Private->Udp6ReadChild, &gEfiUdp6ProtocolGuid, (VOID **) &Private->Udp6Read, This->DriverBindingHandle, ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Create Udp6 child and open Udp6 protocol for PxeBc->UdpWrite. // Status = NetLibCreateServiceChild ( ControllerHandle, This->DriverBindingHandle, &gEfiUdp6ServiceBindingProtocolGuid, &Private->Udp6WriteChild ); if (EFI_ERROR (Status)) { goto ON_ERROR; } Status = gBS->OpenProtocol ( Private->Udp6WriteChild, &gEfiUdp6ProtocolGuid, (VOID **) &Private->Udp6Write, This->DriverBindingHandle, ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Create Ip6 child and open Ip6 protocol for background ICMP6 packets. // Status = NetLibCreateServiceChild ( ControllerHandle, This->DriverBindingHandle, &gEfiIp6ServiceBindingProtocolGuid, &Private->Ip6Child ); if (EFI_ERROR (Status)) { goto ON_ERROR; } Status = gBS->OpenProtocol ( Private->Ip6Child, &gEfiIp6ProtocolGuid, (VOID **) &Private->Ip6, This->DriverBindingHandle, ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Get max packet size from Ip6 to calculate block size for Tftp later. // Status = Private->Ip6->GetModeData (Private->Ip6, &Ip6ModeData, NULL, NULL); if (EFI_ERROR (Status)) { goto ON_ERROR; } Private->Ip6MaxPacketSize = Ip6ModeData.MaxPacketSize; // // Locate Ip6->Ip6Config and store it for set IPv6 address. // Status = gBS->HandleProtocol ( ControllerHandle, &gEfiIp6ConfigProtocolGuid, (VOID **) &Private->Ip6Cfg ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Create a device path node for Ipv6 virtual nic, and append it. // ZeroMem (&Ip6Node, sizeof (IPv6_DEVICE_PATH)); Ip6Node.Header.Type = MESSAGING_DEVICE_PATH; Ip6Node.Header.SubType = MSG_IPv6_DP; Ip6Node.PrefixLength = IP6_PREFIX_LENGTH; SetDevicePathNodeLength (&Ip6Node.Header, sizeof (Ip6Node)); Private->Ip6Nic->DevicePath = AppendDevicePathNode (Private->DevicePath, &Ip6Node.Header); if (Private->Ip6Nic->DevicePath == NULL) { Status = EFI_OUT_OF_RESOURCES; goto ON_ERROR; } CopyMem ( &Private->Ip6Nic->LoadFile, &gLoadFileProtocolTemplate, sizeof (EFI_LOAD_FILE_PROTOCOL) ); // // Create a new handle for IPv6 virtual nic, // and install PxeBaseCode, LoadFile and DevicePath protocols. // Status = gBS->InstallMultipleProtocolInterfaces ( &Private->Ip6Nic->Controller, &gEfiDevicePathProtocolGuid, Private->Ip6Nic->DevicePath, &gEfiLoadFileProtocolGuid, &Private->Ip6Nic->LoadFile, &gEfiPxeBaseCodeProtocolGuid, &Private->PxeBc, NULL ); if (EFI_ERROR (Status)) { goto ON_ERROR; } if (Private->Snp != NULL) { // // Install SNP protocol on purpose is for some OS loader backward // compatibility consideration. // Status = gBS->InstallProtocolInterface ( &Private->Ip6Nic->Controller, &gEfiSimpleNetworkProtocolGuid, EFI_NATIVE_INTERFACE, Private->Snp ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Open SNP on the child handle BY_DRIVER. It will prevent any additionally // layering to perform the experiment. // Status = gBS->OpenProtocol ( Private->Ip6Nic->Controller, &gEfiSimpleNetworkProtocolGuid, (VOID **) &Snp, This->DriverBindingHandle, Private->Ip6Nic->Controller, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } } // // Open PxeBaseCodePrivate protocol by child to setup a parent-child relationship between // real NIC handle and the virtual IPv6 NIC handle. // Status = gBS->OpenProtocol ( ControllerHandle, &gEfiCallerIdGuid, (VOID **) &Id, This->DriverBindingHandle, Private->Ip6Nic->Controller, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); if (EFI_ERROR (Status)) { goto ON_ERROR; } // // Set IPv6 avaiable flag and set default configure data for // Udp6Read and Ip6 instance. // Private->Mode.Ipv6Available = TRUE; Udp6CfgData = &Private->Udp6CfgData; Ip6CfgData = &Private->Ip6CfgData; Udp6CfgData->AcceptAnyPort = TRUE; Udp6CfgData->AllowDuplicatePort = TRUE; Udp6CfgData->HopLimit = PXEBC_DEFAULT_HOPLIMIT; Udp6CfgData->ReceiveTimeout = PXEBC_DEFAULT_LIFETIME; Udp6CfgData->TransmitTimeout = PXEBC_DEFAULT_LIFETIME; Ip6CfgData->AcceptIcmpErrors = TRUE; Ip6CfgData->DefaultProtocol = IP6_ICMP; Ip6CfgData->HopLimit = PXEBC_DEFAULT_HOPLIMIT; Ip6CfgData->ReceiveTimeout = PXEBC_DEFAULT_LIFETIME; Ip6CfgData->TransmitTimeout = PXEBC_DEFAULT_LIFETIME; return EFI_SUCCESS; ON_ERROR: PxeBcDestroyIp6Children (This, Private); return Status; }
/** Initialize data for device that supports multiple LUNSs. @param This The Driver Binding Protocol instance. @param Controller The device to initialize. @param Transport Pointer to USB_MASS_TRANSPORT. @param Context Parameter for USB_MASS_DEVICE.Context. @param DevicePath The remaining device path. @param MaxLun The max LUN number. @retval EFI_SUCCESS At least one LUN is initialized successfully. @retval EFI_NOT_FOUND Fail to initialize any of multiple LUNs. **/ EFI_STATUS UsbMassInitMultiLun ( IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE Controller, IN USB_MASS_TRANSPORT *Transport, IN VOID *Context, IN EFI_DEVICE_PATH_PROTOCOL *DevicePath, IN UINT8 MaxLun ) { USB_MASS_DEVICE *UsbMass; EFI_USB_IO_PROTOCOL *UsbIo; DEVICE_LOGICAL_UNIT_DEVICE_PATH LunNode; UINT8 Index; EFI_STATUS Status; EFI_STATUS ReturnStatus; ASSERT (MaxLun > 0); ReturnStatus = EFI_NOT_FOUND; for (Index = 0; Index <= MaxLun; Index++) { DEBUG ((EFI_D_INFO, "UsbMassInitMultiLun: Start to initialize No.%d logic unit\n", Index)); UsbIo = NULL; UsbMass = AllocateZeroPool (sizeof (USB_MASS_DEVICE)); ASSERT (UsbMass != NULL); UsbMass->Signature = USB_MASS_SIGNATURE; UsbMass->UsbIo = UsbIo; UsbMass->BlockIo.Media = &UsbMass->BlockIoMedia; UsbMass->BlockIo.Reset = UsbMassReset; UsbMass->BlockIo.ReadBlocks = UsbMassReadBlocks; UsbMass->BlockIo.WriteBlocks = UsbMassWriteBlocks; UsbMass->BlockIo.FlushBlocks = UsbMassFlushBlocks; UsbMass->OpticalStorage = FALSE; UsbMass->Transport = Transport; UsbMass->Context = Context; UsbMass->Lun = Index; // // Initialize the media parameter data for EFI_BLOCK_IO_MEDIA of Block I/O Protocol. // Status = UsbMassInitMedia (UsbMass); if ((EFI_ERROR (Status)) && (Status != EFI_NO_MEDIA)) { DEBUG ((EFI_D_ERROR, "UsbMassInitMultiLun: UsbMassInitMedia (%r)\n", Status)); FreePool (UsbMass); continue; } // // Create a device path node for device logic unit, and append it. // LunNode.Header.Type = MESSAGING_DEVICE_PATH; LunNode.Header.SubType = MSG_DEVICE_LOGICAL_UNIT_DP; LunNode.Lun = UsbMass->Lun; SetDevicePathNodeLength (&LunNode.Header, sizeof (LunNode)); UsbMass->DevicePath = AppendDevicePathNode (DevicePath, &LunNode.Header); if (UsbMass->DevicePath == NULL) { DEBUG ((EFI_D_ERROR, "UsbMassInitMultiLun: failed to create device logic unit device path\n")); Status = EFI_OUT_OF_RESOURCES; FreePool (UsbMass); continue; } InitializeDiskInfo (UsbMass); // // Create a new handle for each LUN, and install Block I/O Protocol and Device Path Protocol. // Status = gBS->InstallMultipleProtocolInterfaces ( &UsbMass->Controller, &gEfiDevicePathProtocolGuid, UsbMass->DevicePath, &gEfiBlockIoProtocolGuid, &UsbMass->BlockIo, &gEfiDiskInfoProtocolGuid, &UsbMass->DiskInfo, NULL ); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "UsbMassInitMultiLun: InstallMultipleProtocolInterfaces (%r)\n", Status)); FreePool (UsbMass->DevicePath); FreePool (UsbMass); continue; } // // Open USB I/O Protocol by child to setup a parent-child relationship. // Status = gBS->OpenProtocol ( Controller, &gEfiUsbIoProtocolGuid, (VOID **) &UsbIo, This->DriverBindingHandle, UsbMass->Controller, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "UsbMassInitMultiLun: OpenUsbIoProtocol By Child (%r)\n", Status)); gBS->UninstallMultipleProtocolInterfaces ( &UsbMass->Controller, &gEfiDevicePathProtocolGuid, UsbMass->DevicePath, &gEfiBlockIoProtocolGuid, &UsbMass->BlockIo, &gEfiDiskInfoProtocolGuid, &UsbMass->DiskInfo, NULL ); FreePool (UsbMass->DevicePath); FreePool (UsbMass); continue; } ReturnStatus = EFI_SUCCESS; DEBUG ((EFI_D_INFO, "UsbMassInitMultiLun: Success to initialize No.%d logic unit\n", Index)); } return ReturnStatus; }
EFI_DEVICE_PATH * FvFilePath ( UINTN FvBaseAddress, UINTN FvSize, EFI_GUID *FileGuid ) { EFI_STATUS Status; EFI_LOADED_IMAGE_PROTOCOL *LoadedImage; MEDIA_FW_VOL_FILEPATH_DEVICE_PATH FileNode; EFI_HANDLE FvProtocolHandle; EFI_HANDLE *FvHandleBuffer; UINTN FvHandleCount; EFI_FV_FILETYPE Type; UINTN Size; EFI_FV_FILE_ATTRIBUTES Attributes; UINT32 AuthenticationStatus; EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv; UINTN Index; EfiInitializeFwVolDevicepathNode (&FileNode, FileGuid); if (FvBaseAddress == 0) { Status = gBS->HandleProtocol ( gImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &LoadedImage ); ASSERT_EFI_ERROR (Status); return AppendDevicePathNode ( DevicePathFromHandle (LoadedImage->DeviceHandle), (EFI_DEVICE_PATH_PROTOCOL *) &FileNode ); } else { // // Expose Payload file in FV // gDS->ProcessFirmwareVolume ( (VOID *)FvBaseAddress, (UINT32)FvSize, &FvProtocolHandle ); // // Find out the handle of FV containing the playload file // FvHandleBuffer = NULL; gBS->LocateHandleBuffer ( ByProtocol, &gEfiFirmwareVolume2ProtocolGuid, NULL, &FvHandleCount, &FvHandleBuffer ); for (Index = 0; Index < FvHandleCount; Index++) { gBS->HandleProtocol ( FvHandleBuffer[Index], &gEfiFirmwareVolume2ProtocolGuid, (VOID **) &Fv ); Status = Fv->ReadFile ( Fv, FileGuid, NULL, &Size, &Type, &Attributes, &AuthenticationStatus ); if (!EFI_ERROR (Status)) { break; } } if (Index < FvHandleCount) { return AppendDevicePathNode ( DevicePathFromHandle (FvHandleBuffer[Index]), ( EFI_DEVICE_PATH_PROTOCOL *) &FileNode ); } } return NULL; }
/** Install BlkIo, BlkIo2 and Ssp protocols for the specified partition in the EMMC device. @param[in] Device The pointer to the EMMC_DEVICE data structure. @param[in] Index The index of the partition. @retval EFI_SUCCESS The protocols are installed successfully. @retval Others Some error occurs when installing the protocols. **/ EFI_STATUS InstallProtocolOnPartition ( IN EMMC_DEVICE *Device, IN UINT8 Index ) { EFI_STATUS Status; EMMC_PARTITION *Partition; CONTROLLER_DEVICE_PATH ControlNode; EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; EFI_DEVICE_PATH_PROTOCOL *DevicePath; EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath; EFI_HANDLE DeviceHandle; // // Build device path // ParentDevicePath = Device->DevicePath; ControlNode.Header.Type = HARDWARE_DEVICE_PATH; ControlNode.Header.SubType = HW_CONTROLLER_DP; SetDevicePathNodeLength (&ControlNode.Header, sizeof (CONTROLLER_DEVICE_PATH)); ControlNode.ControllerNumber = Index; DevicePath = AppendDevicePathNode (ParentDevicePath, (EFI_DEVICE_PATH_PROTOCOL*)&ControlNode); if (DevicePath == NULL) { Status = EFI_OUT_OF_RESOURCES; goto Error; } DeviceHandle = NULL; RemainingDevicePath = DevicePath; Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &RemainingDevicePath, &DeviceHandle); if (!EFI_ERROR (Status) && (DeviceHandle != NULL) && IsDevicePathEnd(RemainingDevicePath)) { Status = EFI_ALREADY_STARTED; goto Error; } Partition = &Device->Partition[Index]; Partition->DevicePath = DevicePath; if (Partition->Enable) { // // Install BlkIo/BlkIo2/Ssp for the specified partition // Status = gBS->InstallMultipleProtocolInterfaces ( &Partition->Handle, &gEfiDevicePathProtocolGuid, Partition->DevicePath, &gEfiBlockIoProtocolGuid, &Partition->BlockIo, &gEfiBlockIo2ProtocolGuid, &Partition->BlockIo2, NULL ); if (EFI_ERROR (Status)) { goto Error; } if (Partition->PartitionType != EmmcPartitionRPMB) { Status = gBS->InstallProtocolInterface ( &Partition->Handle, &gEfiEraseBlockProtocolGuid, EFI_NATIVE_INTERFACE, &Partition->EraseBlock ); if (EFI_ERROR (Status)) { gBS->UninstallMultipleProtocolInterfaces ( &Partition->Handle, &gEfiDevicePathProtocolGuid, Partition->DevicePath, &gEfiBlockIoProtocolGuid, &Partition->BlockIo, &gEfiBlockIo2ProtocolGuid, &Partition->BlockIo2, NULL ); goto Error; } } if (((Partition->PartitionType == EmmcPartitionUserData) || (Partition->PartitionType == EmmcPartitionBoot1) || (Partition->PartitionType == EmmcPartitionBoot2)) && ((Device->Csd.Ccc & BIT10) != 0)) { Status = gBS->InstallProtocolInterface ( &Partition->Handle, &gEfiStorageSecurityCommandProtocolGuid, EFI_NATIVE_INTERFACE, &Partition->StorageSecurity ); if (EFI_ERROR (Status)) { gBS->UninstallMultipleProtocolInterfaces ( &Partition->Handle, &gEfiDevicePathProtocolGuid, Partition->DevicePath, &gEfiBlockIoProtocolGuid, &Partition->BlockIo, &gEfiBlockIo2ProtocolGuid, &Partition->BlockIo2, &gEfiEraseBlockProtocolGuid, &Partition->EraseBlock, NULL ); goto Error; } } gBS->OpenProtocol ( Device->Private->Controller, &gEfiSdMmcPassThruProtocolGuid, (VOID **) &(Device->Private->PassThru), Device->Private->DriverBindingHandle, Partition->Handle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); } else { Status = EFI_INVALID_PARAMETER; } Error: if (EFI_ERROR (Status) && (DevicePath != NULL)) { FreePool (DevicePath); } return Status; }