VirtualBox

Ignore:
Timestamp:
Apr 14, 2023 3:17:44 PM (22 months ago)
Author:
vboxsync
Message:

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643

Location:
trunk/src/VBox/Devices/EFI/FirmwareNew
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/EFI/FirmwareNew

  • trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/UefiPxeBcDxe/PxeBcBoot.c

    r85718 r99404  
    1010
    1111#include "PxeBcImpl.h"
    12 
    1312
    1413/**
    … …  
    2322VOID
    2423PxeBcDisplayBootItem (
    25   IN UINT8                 *Str,
    26   IN UINT8                 Len
     24  IN UINT8  *Str,
     25  IN UINT8  Len
    2726  )
    2827{
    29   UINT8                    Tmp;
     28  UINT8  Tmp;
    3029
    3130  //
    3231  // Cut off the chars behind 70th.
    3332  //
    34   Len       = (UINT8) MIN (PXEBC_DISPLAY_MAX_LINE, Len);
    35   Tmp       = Str[Len];
    36   Str[Len]  = 0;
     33  Len      = (UINT8)MIN (PXEBC_DISPLAY_MAX_LINE, Len);
     34  Tmp      = Str[Len];
     35  Str[Len] = 0;
    3736  AsciiPrint ("%a \n", Str);
    3837
    … …  
    4039  // Restore the original 70th char.
    4140  //
    42   Str[Len]  = Tmp;
     41  Str[Len] = Tmp;
    4342}
    44 
    4543
    4644/**
    … …  
    5856EFI_STATUS
    5957PxeBcSelectBootPrompt (
    60   IN PXEBC_PRIVATE_DATA      *Private
     58  IN PXEBC_PRIVATE_DATA  *Private
    6159  )
    6260{
    63   PXEBC_DHCP_PACKET_CACHE    *Cache;
    64   PXEBC_VENDOR_OPTION        *VendorOpt;
    65   EFI_PXE_BASE_CODE_MODE     *Mode;
    66   EFI_EVENT                  TimeoutEvent;
    67   EFI_EVENT                  DescendEvent;
    68   EFI_INPUT_KEY              InputKey;
    69   EFI_STATUS                 Status;
    70   UINT32                     OfferType;
    71   UINT8                      Timeout;
    72   UINT8                      *Prompt;
    73   UINT8                      PromptLen;
    74   INT32                      SecCol;
    75   INT32                      SecRow;
     61  PXEBC_DHCP_PACKET_CACHE  *Cache;
     62  PXEBC_VENDOR_OPTION      *VendorOpt;
     63  EFI_PXE_BASE_CODE_MODE   *Mode;
     64  EFI_EVENT                TimeoutEvent;
     65  EFI_EVENT                DescendEvent;
     66  EFI_INPUT_KEY            InputKey;
     67  EFI_STATUS               Status;
     68  UINT32                   OfferType;
     69  UINT8                    Timeout;
     70  UINT8                    *Prompt;
     71  UINT8                    PromptLen;
     72  INT32                    SecCol;
     73  INT32                    SecRow;
    7674
    7775  TimeoutEvent = NULL;
    … …  
    8482  // Only DhcpPxe10 and ProxyPxe10 offer needs boot prompt.
    8583  //
    86   if (OfferType != PxeOfferTypeProxyPxe10 && OfferType != PxeOfferTypeDhcpPxe10) {
     84  if ((OfferType != PxeOfferTypeProxyPxe10) && (OfferType != PxeOfferTypeDhcpPxe10)) {
    8785    return EFI_NOT_FOUND;
    8886  }
    … …  
    10199  //
    102100  if (IS_DISABLE_PROMPT_MENU (VendorOpt->DiscoverCtrl) &&
    103       Cache->Dhcp4.OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {
     101      (Cache->Dhcp4.OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL))
     102  {
    104103    return EFI_ABORTED;
    105104  }
    … …  
    111110  Timeout   = VendorOpt->MenuPrompt->Timeout;
    112111  Prompt    = VendorOpt->MenuPrompt->Prompt;
    113   PromptLen = (UINT8) (VendorOpt->MenuPromptLen - 1);
     112  PromptLen = (UINT8)(VendorOpt->MenuPromptLen - 1);
    114113
    115114  //
    … …  
    119118    return EFI_TIMEOUT;
    120119  }
     120
    121121  if (Timeout == 255) {
    122122    return EFI_SUCCESS;
    … …  
    186186      AsciiPrint ("(%d) ", Timeout--);
    187187    }
     188
    188189    if (gST->ConIn->ReadKeyStroke (gST->ConIn, &InputKey) == EFI_NOT_READY) {
    189190      gBS->Stall (10 * TICKS_PER_MS);
    190191      continue;
    191192    }
     193
    192194    //
    193195    // Parse the input key by user.
    … …  
    195197    //
    196198    if (InputKey.ScanCode == 0) {
    197 
    198199      switch (InputKey.UnicodeChar) {
    199 
    200       case CTRL ('c'):
    201         Status = EFI_ABORTED;
    202         break;
    203 
    204       case CTRL ('m'):
    205       case 'm':
    206       case 'M':
    207         Status = EFI_SUCCESS;
    208         break;
    209 
    210       default:
    211         continue;
     200        case CTRL ('c'):
     201          Status = EFI_ABORTED;
     202          break;
     203
     204        case CTRL ('m'):
     205        case 'm':
     206        case 'M':
     207          Status = EFI_SUCCESS;
     208          break;
     209
     210        default:
     211          continue;
    212212      }
    213 
    214213    } else {
    215 
    216214      switch (InputKey.ScanCode) {
    217 
    218       case SCAN_F8:
    219         Status = EFI_SUCCESS;
    220         break;
    221 
    222       case SCAN_ESC:
    223         Status = EFI_ABORTED;
    224         break;
    225 
    226       default:
    227         continue;
     215        case SCAN_F8:
     216          Status = EFI_SUCCESS;
     217          break;
     218
     219        case SCAN_ESC:
     220          Status = EFI_ABORTED;
     221          break;
     222
     223        default:
     224          continue;
    228225      }
    229226    }
    … …  
    235232  // Reset the cursor on the screen.
    236233  //
    237   gST->ConOut->SetCursorPosition (gST->ConOut, 0 , SecRow + 1);
     234  gST->ConOut->SetCursorPosition (gST->ConOut, 0, SecRow + 1);
    238235
    239236ON_EXIT:
    … …  
    241238    gBS->CloseEvent (DescendEvent);
    242239  }
     240
    243241  if (TimeoutEvent != NULL) {
    244242    gBS->CloseEvent (TimeoutEvent);
    … …  
    247245  return Status;
    248246}
    249 
    250247
    251248/**
    … …  
    263260EFI_STATUS
    264261PxeBcSelectBootMenu (
    265   IN  PXEBC_PRIVATE_DATA              *Private,
    266   OUT UINT16                          *Type,
    267   IN  BOOLEAN                         UseDefaultItem
     262  IN  PXEBC_PRIVATE_DATA  *Private,
     263  OUT UINT16              *Type,
     264  IN  BOOLEAN             UseDefaultItem
    268265  )
    269266{
    270   EFI_PXE_BASE_CODE_MODE     *Mode;
    271   PXEBC_DHCP_PACKET_CACHE    *Cache;
    272   PXEBC_VENDOR_OPTION        *VendorOpt;
    273   EFI_INPUT_KEY              InputKey;
    274   UINT32                     OfferType;
    275   UINT8                      MenuSize;
    276   UINT8                      MenuNum;
    277   INT32                      TopRow;
    278   UINT16                     Select;
    279   UINT16                     LastSelect;
    280   UINT8                      Index;
    281   BOOLEAN                    Finish;
    282   CHAR8                      Blank[PXEBC_DISPLAY_MAX_LINE];
    283   PXEBC_BOOT_MENU_ENTRY      *MenuItem;
    284   PXEBC_BOOT_MENU_ENTRY      *MenuArray[PXEBC_MENU_MAX_NUM];
     267  EFI_PXE_BASE_CODE_MODE   *Mode;
     268  PXEBC_DHCP_PACKET_CACHE  *Cache;
     269  PXEBC_VENDOR_OPTION      *VendorOpt;
     270  EFI_INPUT_KEY            InputKey;
     271  UINT32                   OfferType;
     272  UINT8                    MenuSize;
     273  UINT8                    MenuNum;
     274  INT32                    TopRow;
     275  UINT16                   Select;
     276  UINT16                   LastSelect;
     277  UINT8                    Index;
     278  BOOLEAN                  Finish;
     279  CHAR8                    Blank[PXEBC_DISPLAY_MAX_LINE];
     280  PXEBC_BOOT_MENU_ENTRY    *MenuItem;
     281  PXEBC_BOOT_MENU_ENTRY    *MenuArray[PXEBC_MENU_MAX_NUM];
    285282
    286283  Finish    = FALSE;
    … …  
    306303  // Display the boot menu on the screen.
    307304  //
    308   SetMem (Blank, sizeof(Blank), ' ');
    309 
    310   MenuSize  = VendorOpt->BootMenuLen;
    311   MenuItem  = VendorOpt->BootMenu;
     305  SetMem (Blank, sizeof (Blank), ' ');
     306
     307  MenuSize = VendorOpt->BootMenuLen;
     308  MenuItem = VendorOpt->BootMenu;
    312309
    313310  if (MenuSize == 0) {
    … …  
    317314  while (MenuSize > 0 && Index < PXEBC_MENU_MAX_NUM) {
    318315    ASSERT (MenuItem != NULL);
    319     MenuArray[Index]  = MenuItem;
    320     MenuSize          = (UINT8) (MenuSize - (MenuItem->DescLen + 3));
    321     MenuItem          = (PXEBC_BOOT_MENU_ENTRY *) ((UINT8 *) MenuItem + MenuItem->DescLen + 3);
     316    MenuArray[Index] = MenuItem;
     317    MenuSize         = (UINT8)(MenuSize - (MenuItem->DescLen + 3));
     318    MenuItem         = (PXEBC_BOOT_MENU_ENTRY *)((UINT8 *)MenuItem + MenuItem->DescLen + 3);
    322319    Index++;
    323320  }
    … …  
    362359    if (InputKey.ScanCode == 0) {
    363360      switch (InputKey.UnicodeChar) {
    364       case CTRL ('c'):
    365         InputKey.ScanCode = SCAN_ESC;
     361        case CTRL ('c'):
     362          InputKey.ScanCode = SCAN_ESC;
     363          break;
     364
     365        case CTRL ('j'): /* linefeed */
     366        case CTRL ('m'): /* return */
     367          Finish = TRUE;
     368          break;
     369
     370        case CTRL ('i'): /* tab */
     371        case ' ':
     372        case 'd':
     373        case 'D':
     374          InputKey.ScanCode = SCAN_DOWN;
     375          break;
     376
     377        case CTRL ('h'): /* backspace */
     378        case 'u':
     379        case 'U':
     380          InputKey.ScanCode = SCAN_UP;
     381          break;
     382
     383        default:
     384          InputKey.ScanCode = 0;
     385      }
     386    }
     387
     388    switch (InputKey.ScanCode) {
     389      case SCAN_LEFT:
     390      case SCAN_UP:
     391        if (Select != 0) {
     392          Select--;
     393        }
     394
    366395        break;
    367396
    368       case CTRL ('j'):  /* linefeed */
    369       case CTRL ('m'):  /* return */
    370         Finish = TRUE;
     397      case SCAN_DOWN:
     398      case SCAN_RIGHT:
     399        if (++Select == MenuNum) {
     400          Select--;
     401        }
     402
    371403        break;
    372404
    373       case CTRL ('i'):  /* tab */
    374       case ' ':
    375       case 'd':
    376       case 'D':
    377         InputKey.ScanCode = SCAN_DOWN;
     405      case SCAN_PAGE_UP:
     406      case SCAN_HOME:
     407        Select = 0;
    378408        break;
    379409
    380       case CTRL ('h'):  /* backspace */
    381       case 'u':
    382       case 'U':
    383         InputKey.ScanCode = SCAN_UP;
     410      case SCAN_PAGE_DOWN:
     411      case SCAN_END:
     412        Select = (UINT16)(MenuNum - 1);
    384413        break;
    385414
    386       default:
    387         InputKey.ScanCode = 0;
    388       }
    389     }
    390 
    391     switch (InputKey.ScanCode) {
    392     case SCAN_LEFT:
    393     case SCAN_UP:
    394       if (Select != 0) {
    395         Select--;
    396       }
    397       break;
    398 
    399     case SCAN_DOWN:
    400     case SCAN_RIGHT:
    401       if (++Select == MenuNum) {
    402         Select--;
    403       }
    404       break;
    405 
    406     case SCAN_PAGE_UP:
    407     case SCAN_HOME:
    408       Select = 0;
    409       break;
    410 
    411     case SCAN_PAGE_DOWN:
    412     case SCAN_END:
    413       Select = (UINT16) (MenuNum - 1);
    414       break;
    415 
    416     case SCAN_ESC:
    417       return EFI_ABORTED;
     415      case SCAN_ESC:
     416        return EFI_ABORTED;
    418417    }
    419418
    … …  
    442441}
    443442
    444 
    445443/**
    446444  Parse out the boot information from the last Dhcp4 reply packet.
    … …  
    455453EFI_STATUS
    456454PxeBcDhcp4BootInfo (
    457   IN OUT PXEBC_PRIVATE_DATA   *Private,
    458      OUT UINT64               *BufferSize
     455  IN OUT PXEBC_PRIVATE_DATA  *Private,
     456  OUT UINT64                 *BufferSize
    459457  )
    460458{
    … …  
    507505  if (IS_DISABLE_PROMPT_MENU (VendorOpt->DiscoverCtrl) && IS_VALID_BOOT_SERVERS (VendorOpt->BitMap)) {
    508506    Entry = VendorOpt->BootSvr;
    509     if (VendorOpt->BootSvrLen >= sizeof (PXEBC_BOOT_SVR_ENTRY) && Entry->IpCnt > 0) {
     507    if ((VendorOpt->BootSvrLen >= sizeof (PXEBC_BOOT_SVR_ENTRY)) && (Entry->IpCnt > 0)) {
    510508      CopyMem (
    511509        &Private->ServerIp,
    … …  
    515513    }
    516514  }
     515
    517516  if (Private->ServerIp.Addr[0] == 0) {
    518517    //
    … …  
    526525      );
    527526  }
     527
    528528  if (Private->ServerIp.Addr[0] == 0) {
    529529    //
    … …  
    547547    //
    548548    CopyMem (&Value, Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE_LEN]->Data, sizeof (Value));
    549     Value       = NTOHS (Value);
     549    Value = NTOHS (Value);
    550550    //
    551551    // The field of boot file size is 512 bytes in unit.
    … …  
    573573  // Save the value of boot file size.
    574574  //
    575   Private->BootFileSize = (UINTN) *BufferSize;
     575  Private->BootFileSize = (UINTN)*BufferSize;
    576576
    577577  //
    … …  
    586586}
    587587
    588 
    589588/**
    590589  Parse out the boot information from the last Dhcp6 reply packet.
    … …  
    600599EFI_STATUS
    601600PxeBcDhcp6BootInfo (
    602   IN OUT PXEBC_PRIVATE_DATA   *Private,
    603      OUT UINT64               *BufferSize
     601  IN OUT PXEBC_PRIVATE_DATA  *Private,
     602  OUT UINT64                 *BufferSize
    604603  )
    605604{
    … …  
    649648  }
    650649
    651 
    652650  //
    653651  // Parse (m)tftp server ip address and bootfile name.
    … …  
    657655             &Private->BootFileName,
    658656             &Private->ServerIp.v6,
    659              (CHAR8 *) (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL]->Data),
     657             (CHAR8 *)(Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL]->Data),
    660658             NTOHS (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL]->OpLen)
    661659             );
    … …  
    671669    // Parse it out if have the boot file parameter option.
    672670    //
    673     Status = PxeBcExtractBootFileParam ((CHAR8 *) Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_PARAM]->Data, &Value);
     671    Status = PxeBcExtractBootFileParam ((CHAR8 *)Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_PARAM]->Data, &Value);
    674672    if (EFI_ERROR (Status)) {
    675673      return Status;
    676674    }
     675
    677676    //
    678677    // The field of boot file size is 512 bytes in unit.
    … …  
    700699  // Save the value of boot file size.
    701700  //
    702   Private->BootFileSize = (UINTN) *BufferSize;
     701  Private->BootFileSize = (UINTN)*BufferSize;
    703702
    704703  //
    … …  
    712711  return Status;
    713712}
    714 
    715713
    716714/**
    … …  
    733731  IN     UINT16                           Type,
    734732  IN OUT EFI_PXE_BASE_CODE_DISCOVER_INFO  **DiscoverInfo,
    735      OUT PXEBC_BOOT_SVR_ENTRY             **BootEntry,
    736      OUT EFI_PXE_BASE_CODE_SRVLIST        **SrvList
     733  OUT PXEBC_BOOT_SVR_ENTRY                **BootEntry,
     734  OUT EFI_PXE_BASE_CODE_SRVLIST           **SrvList
    737735  )
    738736{
    739   EFI_PXE_BASE_CODE_MODE          *Mode;
    740   PXEBC_DHCP4_PACKET_CACHE        *Cache4;
    741   PXEBC_VENDOR_OPTION             *VendorOpt;
    742   PXEBC_BOOT_SVR_ENTRY            *Entry;
    743   BOOLEAN                         IsFound;
    744   EFI_PXE_BASE_CODE_DISCOVER_INFO *Info;
    745   UINT16                          Index;
     737  EFI_PXE_BASE_CODE_MODE           *Mode;
     738  PXEBC_DHCP4_PACKET_CACHE         *Cache4;
     739  PXEBC_VENDOR_OPTION              *VendorOpt;
     740  PXEBC_BOOT_SVR_ENTRY             *Entry;
     741  BOOLEAN                          IsFound;
     742  EFI_PXE_BASE_CODE_DISCOVER_INFO  *Info;
     743  UINT16                           Index;
    746744
    747745  Mode = Private->PxeBc.Mode;
    … …  
    760758    CopyMem (&Info->SrvList[0].IpAddr, &Private->ServerIp, sizeof (EFI_IP_ADDRESS));
    761759
    762     *SrvList  = Info->SrvList;
     760    *SrvList = Info->SrvList;
    763761  } else {
    764762    Entry     = NULL;
    … …  
    779777    Info->UseMCast    = (BOOLEAN) !IS_DISABLE_MCAST_DISCOVER (VendorOpt->DiscoverCtrl);
    780778    Info->UseBCast    = (BOOLEAN) !IS_DISABLE_BCAST_DISCOVER (VendorOpt->DiscoverCtrl);
    781     Info->MustUseList = (BOOLEAN) IS_ENABLE_USE_SERVER_LIST (VendorOpt->DiscoverCtrl);
    782     Info->UseUCast    = (BOOLEAN) IS_VALID_BOOT_SERVERS (VendorOpt->BitMap);
     779    Info->MustUseList = (BOOLEAN)IS_ENABLE_USE_SERVER_LIST (VendorOpt->DiscoverCtrl);
     780    Info->UseUCast    = (BOOLEAN)IS_VALID_BOOT_SERVERS (VendorOpt->BitMap);
    783781
    784782    if (Info->UseMCast) {
    … …  
    794792      Entry = VendorOpt->BootSvr;
    795793
    796       while (((UINT8) (Entry - VendorOpt->BootSvr)) < VendorOpt->BootSvrLen) {
     794      while (((UINT8)(Entry - VendorOpt->BootSvr)) < VendorOpt->BootSvrLen) {
    797795        if (Entry->Type == HTONS (Type)) {
    798796          IsFound = TRUE;
    799797          break;
    800798        }
     799
    801800        Entry = GET_NEXT_BOOT_SVR_ENTRY (Entry);
    802801      }
    … …  
    812811          return EFI_OUT_OF_RESOURCES;
    813812        }
     813
    814814        CopyMem (*DiscoverInfo, Info, sizeof (*Info));
    815815        Info = *DiscoverInfo;
    … …  
    819819        CopyMem (&Info->SrvList[Index].IpAddr, &Entry->IpAddr[Index], sizeof (EFI_IPv4_ADDRESS));
    820820        Info->SrvList[Index].AcceptAnyResponse = !Info->MustUseList;
    821         Info->SrvList[Index].Type = NTOHS (Entry->Type);
     821        Info->SrvList[Index].Type              = NTOHS (Entry->Type);
    822822      }
    823823    }
    … …  
    829829  return EFI_SUCCESS;
    830830}
    831 
    832831
    833832/**
    … …  
    850849EFI_STATUS
    851850PxeBcDiscoverBootServer (
    852   IN  PXEBC_PRIVATE_DATA                *Private,
    853   IN  UINT16                            Type,
    854   IN  UINT16                            *Layer,
    855   IN  BOOLEAN                           UseBis,
    856   IN  EFI_IP_ADDRESS                    *DestIp,
    857   IN  UINT16                            IpCount,
    858   IN  EFI_PXE_BASE_CODE_SRVLIST         *SrvList
     851  IN  PXEBC_PRIVATE_DATA         *Private,
     852  IN  UINT16                     Type,
     853  IN  UINT16                     *Layer,
     854  IN  BOOLEAN                    UseBis,
     855  IN  EFI_IP_ADDRESS             *DestIp,
     856  IN  UINT16                     IpCount,
     857  IN  EFI_PXE_BASE_CODE_SRVLIST  *SrvList
    859858  )
    860859{
    … …  
    880879}
    881880
    882 
    883881/**
    884882  Discover all the boot information for boot file.
    … …  
    895893EFI_STATUS
    896894PxeBcDiscoverBootFile (
    897   IN OUT PXEBC_PRIVATE_DATA   *Private,
    898      OUT UINT64               *BufferSize
     895  IN OUT PXEBC_PRIVATE_DATA  *Private,
     896  OUT UINT64                 *BufferSize
    899897  )
    900898{
    … …  
    938936
    939937  if (!EFI_ERROR (Status)) {
    940 
    941938    if (Type == EFI_PXE_BASE_CODE_BOOT_TYPE_BOOTSTRAP) {
    942939      //
    … …  
    950947    // name and bootfile size.
    951948    //
    952     UseBis = (BOOLEAN) (Mode->BisSupported && Mode->BisDetected);
     949    UseBis = (BOOLEAN)(Mode->BisSupported && Mode->BisDetected);
    953950    Status = PxeBc->Discover (PxeBc, Type, &Layer, UseBis, NULL);
    954951    if (EFI_ERROR (Status)) {
    … …  
    974971          );
    975972      }
     973
    976974      Mode->ProxyOfferReceived = TRUE;
    977975    }
    … …  
    989987  return Status;
    990988}
    991 
    992989
    993990/**
    … …  
    10031000EFI_STATUS
    10041001PxeBcInstallCallback (
    1005   IN OUT PXEBC_PRIVATE_DATA   *Private,
    1006      OUT BOOLEAN              *NewMakeCallback
     1002  IN OUT PXEBC_PRIVATE_DATA  *Private,
     1003  OUT BOOLEAN                *NewMakeCallback
    10071004  )
    10081005{
    … …  
    10171014                  Private->Mode.UsingIpv6 ? Private->Ip6Nic->Controller : Private->Ip4Nic->Controller,
    10181015                  &gEfiPxeBaseCodeCallbackProtocolGuid,
    1019                   (VOID **) &Private->PxeBcCallback
     1016                  (VOID **)&Private->PxeBcCallback
    10201017                  );
    10211018  if (Status == EFI_UNSUPPORTED) {
    1022 
    10231019    CopyMem (
    10241020      &Private->LoadFileCallback,
    … …  
    10371033                    );
    10381034
    1039     (*NewMakeCallback) = (BOOLEAN) (Status == EFI_SUCCESS);
     1035    (*NewMakeCallback) = (BOOLEAN)(Status == EFI_SUCCESS);
    10401036
    10411037    Status = PxeBc->SetParameters (PxeBc, NULL, NULL, NULL, NULL, NewMakeCallback);
    … …  
    10491045}
    10501046
    1051 
    10521047/**
    10531048  Uninstall PxeBaseCodeCallbackProtocol.
    … …  
    10601055VOID
    10611056PxeBcUninstallCallback (
    1062   IN PXEBC_PRIVATE_DATA        *Private,
    1063   IN BOOLEAN                   NewMakeCallback
     1057  IN PXEBC_PRIVATE_DATA  *Private,
     1058  IN BOOLEAN             NewMakeCallback
    10641059  )
    10651060{
    1066   EFI_PXE_BASE_CODE_PROTOCOL   *PxeBc;
     1061  EFI_PXE_BASE_CODE_PROTOCOL  *PxeBc;
    10671062
    10681063  PxeBc = &Private->PxeBc;
    10691064
    10701065  if (NewMakeCallback) {
    1071 
    10721066    NewMakeCallback = FALSE;
    10731067
    … …  
    10751069
    10761070    gBS->UninstallProtocolInterface (
    1077           Private->Mode.UsingIpv6 ? Private->Ip6Nic->Controller : Private->Ip4Nic->Controller,
    1078           &gEfiPxeBaseCodeCallbackProtocolGuid,
    1079           &Private->LoadFileCallback
    1080           );
     1071           Private->Mode.UsingIpv6 ? Private->Ip6Nic->Controller : Private->Ip4Nic->Controller,
     1072           &gEfiPxeBaseCodeCallbackProtocolGuid,
     1073           &Private->LoadFileCallback
     1074           );
    10811075  }
    10821076}
    1083 
    10841077
    10851078/**
    … …  
    10991092EFI_STATUS
    11001093PxeBcReadBootFileList (
    1101   IN     PXEBC_PRIVATE_DATA           *Private,
    1102   IN OUT UINT64                       *BufferSize,
    1103   IN     VOID                         *Buffer           OPTIONAL
     1094  IN     PXEBC_PRIVATE_DATA  *Private,
     1095  IN OUT UINT64              *BufferSize,
     1096  IN     VOID                *Buffer           OPTIONAL
    11041097  )
    11051098{
    1106   EFI_STATUS                          Status;
    1107   EFI_PXE_BASE_CODE_PROTOCOL          *PxeBc;
    1108 
    1109   PxeBc        = &Private->PxeBc;
     1099  EFI_STATUS                  Status;
     1100  EFI_PXE_BASE_CODE_PROTOCOL  *PxeBc;
     1101
     1102  PxeBc = &Private->PxeBc;
    11101103
    11111104  //
    … …  
    11251118                      FALSE
    11261119                      );
    1127 
    1128 
    11291120  } else {
    1130     Status      = EFI_BUFFER_TOO_SMALL;
     1121    Status = EFI_BUFFER_TOO_SMALL;
    11311122  }
    11321123
    11331124  return Status;
    11341125}
    1135 
    11361126
    11371127/**
    … …  
    11511141EFI_STATUS
    11521142PxeBcLoadBootFile (
    1153   IN     PXEBC_PRIVATE_DATA           *Private,
    1154   IN OUT UINTN                        *BufferSize,
    1155   IN     VOID                         *Buffer         OPTIONAL
     1143  IN     PXEBC_PRIVATE_DATA  *Private,
     1144  IN OUT UINTN               *BufferSize,
     1145  IN     VOID                *Buffer         OPTIONAL
    11561146  )
    11571147{
    1158   BOOLEAN                             NewMakeCallback;
    1159   UINT64                              RequiredSize;
    1160   UINT64                              CurrentSize;
    1161   EFI_STATUS                          Status;
    1162   EFI_PXE_BASE_CODE_PROTOCOL          *PxeBc;
    1163   EFI_PXE_BASE_CODE_MODE              *PxeBcMode;
     1148  BOOLEAN                     NewMakeCallback;
     1149  UINT64                      RequiredSize;
     1150  UINT64                      CurrentSize;
     1151  EFI_STATUS                  Status;
     1152  EFI_PXE_BASE_CODE_PROTOCOL  *PxeBc;
     1153  EFI_PXE_BASE_CODE_MODE      *PxeBcMode;
    11641154
    11651155  NewMakeCallback = FALSE;
    … …  
    11731163  //
    11741164  Status = PxeBcInstallCallback (Private, &NewMakeCallback);
    1175   if (EFI_ERROR(Status)) {
     1165  if (EFI_ERROR (Status)) {
    11761166    return Status;
    11771167  }
    … …  
    11961186      // Get the right buffer size of the bootfile required.
    11971187      //
    1198       if (CurrentSize < RequiredSize || Buffer == NULL) {
     1188      if ((CurrentSize < RequiredSize) || (Buffer == NULL)) {
    11991189        //
    12001190        // It's buffer too small if the size of user buffer is smaller than the required.
    … …  
    12041194        goto ON_EXIT;
    12051195      }
     1196
    12061197      CurrentSize = RequiredSize;
    1207     } else if (RequiredSize == 0 && PxeBcMode->UsingIpv6) {
     1198    } else if ((RequiredSize == 0) && PxeBcMode->UsingIpv6) {
    12081199      //
    12091200      // Try to download another bootfile in list if failed to get the filesize of the last one.
    … …  
    12131204      goto ON_EXIT;
    12141205    }
    1215   } else if (CurrentSize < Private->BootFileSize || Buffer == NULL ) {
     1206  } else if ((CurrentSize < Private->BootFileSize) || (Buffer == NULL)) {
    12161207    //
    12171208    // It's buffer too small if the size of user buffer is smaller than the required.
    … …  
    12481239
    12491240ON_EXIT:
    1250   *BufferSize = (UINTN) CurrentSize;
    1251   PxeBcUninstallCallback(Private, NewMakeCallback);
     1241  *BufferSize = (UINTN)CurrentSize;
     1242  PxeBcUninstallCallback (Private, NewMakeCallback);
    12521243
    12531244  if (Status == EFI_SUCCESS) {
    12541245    AsciiPrint ("\n  NBP file downloaded successfully.\n");
    12551246    return EFI_SUCCESS;
    1256   } else if (Status == EFI_BUFFER_TOO_SMALL && Buffer != NULL) {
     1247  } else if ((Status == EFI_BUFFER_TOO_SMALL) && (Buffer != NULL)) {
    12571248    AsciiPrint ("\n  PXE-E05: Buffer size is smaller than the requested file.\n");
    12581249  } else if (Status == EFI_DEVICE_ERROR) {
    … …  
    12801271  return Status;
    12811272}
    1282 
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette