CloverBootloader/CloverEFI/OsxEfiLdr/Support.c

/*++

Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials                          
are licensed and made available under the terms and conditions of the BSD License         
which accompanies this distribution.  The full text of the license may be found at        
http://opensource.org/licenses/bsd-license.php                                            
                                                                                          
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

Module Name:
  Support.c

Abstract:

Revision History:

--*/
#include "EfiLdr.h"
//#include "Debug.h"

EFI_STATUS
EfiAddMemoryDescriptor(
  UINTN                 *NoDesc,
  EFI_MEMORY_DESCRIPTOR *Desc,
  EFI_MEMORY_TYPE       Type,
  EFI_PHYSICAL_ADDRESS  BaseAddress,
  UINT64                NoPages,
  UINT64                Attribute
  )
{
  UINTN  NumberOfDesc;
  UINT64 Temp;
  UINTN  Index;

  if (NoPages == 0) {
    return EFI_SUCCESS;
  }

  //
  // See if the new memory descriptor needs to be carved out of an existing memory descriptor
  //

  NumberOfDesc = *NoDesc;
  for (Index = 0; Index < NumberOfDesc; Index++) {

    if (Desc[Index].Type == EfiConventionalMemory) {

      Temp = DivU64x32 ((BaseAddress - Desc[Index].PhysicalStart), EFI_PAGE_SIZE) + NoPages;

      if ((Desc[Index].PhysicalStart < BaseAddress) && (Desc[Index].NumberOfPages >= Temp)) {
        if (Desc[Index].NumberOfPages > Temp) {
          Desc[*NoDesc].Type          = EfiConventionalMemory;
          Desc[*NoDesc].PhysicalStart = BaseAddress + MultU64x32 (NoPages, EFI_PAGE_SIZE);
          Desc[*NoDesc].NumberOfPages = Desc[Index].NumberOfPages - Temp;
          Desc[*NoDesc].VirtualStart  = 0;
          Desc[*NoDesc].Attribute     = Desc[Index].Attribute;
          *NoDesc = *NoDesc + 1;
        }
        Desc[Index].NumberOfPages = Temp - NoPages;
      }

      if ((Desc[Index].PhysicalStart == BaseAddress) && (Desc[Index].NumberOfPages == NoPages)) {
        Desc[Index].Type      = Type;
        Desc[Index].Attribute = Attribute;
        return EFI_SUCCESS;
      }

      if ((Desc[Index].PhysicalStart == BaseAddress) && (Desc[Index].NumberOfPages > NoPages)) {
        Desc[Index].NumberOfPages -= NoPages;
        Desc[Index].PhysicalStart += MultU64x32 (NoPages, EFI_PAGE_SIZE);
      }
    }
  }

  //
  // Add the new memory descriptor
  //

  Desc[*NoDesc].Type          = Type;
  Desc[*NoDesc].PhysicalStart = BaseAddress;
  Desc[*NoDesc].NumberOfPages = NoPages;
  Desc[*NoDesc].VirtualStart  = 0;
  Desc[*NoDesc].Attribute     = Attribute;
  *NoDesc = *NoDesc + 1;

  return EFI_SUCCESS;
}

UINTN
FindSpace (
  UINTN                       NoPages,
  IN UINTN                    *NumberOfMemoryMapEntries,
  IN EFI_MEMORY_DESCRIPTOR    *EfiMemoryDescriptor,
  EFI_MEMORY_TYPE             Type,
  UINT64                      Attribute
  )
{
  EFI_PHYSICAL_ADDRESS        MaxPhysicalStart;
  UINT64                      MaxNoPages;
  UINTN                       Index;
  EFI_MEMORY_DESCRIPTOR       *CurrentMemoryDescriptor;

  MaxPhysicalStart = 0;
  MaxNoPages       = 0;
  CurrentMemoryDescriptor = NULL;
  for (Index = 0; Index < *NumberOfMemoryMapEntries; Index++) {
    if (EfiMemoryDescriptor[Index].PhysicalStart + LShiftU64(EfiMemoryDescriptor[Index].NumberOfPages, EFI_PAGE_SHIFT) <= 0x100000) {
      continue;
    }
    if ((EfiMemoryDescriptor[Index].Type == EfiConventionalMemory) && 
        (EfiMemoryDescriptor[Index].NumberOfPages >= NoPages)) {
      if (EfiMemoryDescriptor[Index].PhysicalStart > MaxPhysicalStart) {
        if (EfiMemoryDescriptor[Index].PhysicalStart + LShiftU64(EfiMemoryDescriptor[Index].NumberOfPages, EFI_PAGE_SHIFT) <= 0x100000000ULL) {
          MaxPhysicalStart = EfiMemoryDescriptor[Index].PhysicalStart;
          MaxNoPages       = EfiMemoryDescriptor[Index].NumberOfPages;
          CurrentMemoryDescriptor = &EfiMemoryDescriptor[Index];
        }
      }
    }
    if ((EfiMemoryDescriptor[Index].Type == EfiReservedMemoryType) ||
        (EfiMemoryDescriptor[Index].Type >= EfiACPIReclaimMemory) ) {
      continue;
    }
    if ((EfiMemoryDescriptor[Index].Type == EfiRuntimeServicesCode) ||
        (EfiMemoryDescriptor[Index].Type == EfiRuntimeServicesData)) {
      break;
    }
  }
 
  if (MaxPhysicalStart == 0) {
    return 0;
  }

  if (MaxNoPages != NoPages) {
    CurrentMemoryDescriptor->NumberOfPages = MaxNoPages - NoPages;
    EfiMemoryDescriptor[*NumberOfMemoryMapEntries].Type          = Type;
    EfiMemoryDescriptor[*NumberOfMemoryMapEntries].PhysicalStart = MaxPhysicalStart + LShiftU64(MaxNoPages - NoPages, EFI_PAGE_SHIFT);
    EfiMemoryDescriptor[*NumberOfMemoryMapEntries].NumberOfPages = NoPages;
    EfiMemoryDescriptor[*NumberOfMemoryMapEntries].VirtualStart  = 0;
    EfiMemoryDescriptor[*NumberOfMemoryMapEntries].Attribute     = Attribute;
    *NumberOfMemoryMapEntries = *NumberOfMemoryMapEntries + 1;
  } else {
    CurrentMemoryDescriptor->Type      = Type;
    CurrentMemoryDescriptor->Attribute = Attribute;
  }

  return (UINTN)(MaxPhysicalStart + LShiftU64(MaxNoPages - NoPages, EFI_PAGE_SHIFT));
}

VOID
GenMemoryMap (
  UINTN                 *NumberOfMemoryMapEntries,
  EFI_MEMORY_DESCRIPTOR *EfiMemoryDescriptor,
  BIOS_MEMORY_MAP       *BiosMemoryMap
  )
{
  UINT64                BaseAddress;
  UINT64                Length;
  EFI_MEMORY_TYPE       Type;
  UINTN                 Index, NumMap;
  UINTN                 Attr;
  UINT64                Ceiling;
  UINT64                EBDAaddr; // = 0x9E000;
  UINT64                EBDAmax = 0x100000;
  UINT64                EBDAsize = 2;

  // EBDA memory protection
  volatile UINT16 * volatile ebda;
  ebda = (volatile UINT16 *)(UINTN)(0x40E);
  EBDAaddr = LShiftU64((UINT64)(*ebda), 4);

//  EBDAaddr = LShiftU64((UINT64)(*(volatile UINT16 *)(UINTN)(0x40E)), 4);
  //fool proof
  if (EBDAaddr < 0x90000 || EBDAaddr > 0x9F800) {
    EBDAaddr = 0x9A000;
  }
  NumMap =  BiosMemoryMap->MemoryMapSize / sizeof(BIOS_MEMORY_MAP_ENTRY);
//  PrintString("Number of entries = %d\n", NumMap);
  Ceiling = 0xFFFFFFFF;
  for (Index = 0; Index < NumMap; Index++) {

    switch (BiosMemoryMap->MemoryMapEntry[Index].Type) { 
    case (INT15_E820_AddressRangeMemory):  //1 kMemoryRangeUsable
      Type = EfiConventionalMemory;
      Attr = EFI_MEMORY_WB;
      break;
    case (INT15_E820_AddressRangeReserved): //2 (Do not use)
      Type = EfiReservedMemoryType;
      Attr = EFI_MEMORY_UC;
      break;
    case (INT15_E820_AddressRangeACPI):  //3
      Type = EfiACPIReclaimMemory;
      Attr = EFI_MEMORY_WB;
      break;
    case (INT15_E820_AddressRangeNVS):  //4 (Do not use)
      Type = EfiACPIMemoryNVS;
      Attr = EFI_MEMORY_UC;
      break;
    default:
      // We should not get here, according to ACPI 2.0 Spec.
      // BIOS behaviour of the Int15h, E820h
      Type = EfiReservedMemoryType;
      Attr = EFI_MEMORY_UC;  //(Do not use)
      break;
    }
    if (Type == EfiConventionalMemory) {
      BaseAddress = BiosMemoryMap->MemoryMapEntry[Index].BaseAddress;
      Length      = BiosMemoryMap->MemoryMapEntry[Index].Length;
      if (BaseAddress & EFI_PAGE_MASK) {
        Length      = Length + (BaseAddress & EFI_PAGE_MASK) - EFI_PAGE_SIZE;
        BaseAddress = LShiftU64 (RShiftU64 (BaseAddress + EFI_PAGE_MASK, EFI_PAGE_SHIFT), EFI_PAGE_SHIFT);
      }
    } else {
      BaseAddress = BiosMemoryMap->MemoryMapEntry[Index].BaseAddress;
      Length      = BiosMemoryMap->MemoryMapEntry[Index].Length + (BaseAddress & EFI_PAGE_MASK);
      BaseAddress = LShiftU64 (RShiftU64 (BaseAddress, EFI_PAGE_SHIFT), EFI_PAGE_SHIFT);
      if (Length & EFI_PAGE_MASK) {
        Length = LShiftU64 (RShiftU64 (Length, EFI_PAGE_SHIFT) + 1, EFI_PAGE_SHIFT);
      }
      //
      // Update Memory Ceiling
      //
      //Slice - there was (BaseAddress >= 0x100000ULL) - the bred of sieve of cable 0x60000000ULL
      if ((BaseAddress >= 0x100000ULL) && (BaseAddress < 0x100000000ULL)) {
        if (Ceiling > BaseAddress) {
          Ceiling = BaseAddress;
        }
      }
      // Ignore the EBDA and bios rom area
      if (BaseAddress < EBDAaddr) {
        if ((BaseAddress + Length) >= EBDAaddr) {
          continue;
        }
      } else if (BaseAddress < EBDAmax) {
        continue;
      }
    }
    //ugly patch
/*    if (BaseAddress == 0x9b000) {
      //EBDA2 protection
      EfiAddMemoryDescriptor (
                              NumberOfMemoryMapEntries,
                              EfiMemoryDescriptor,
                              EfiACPIMemoryNVS,
                              (EFI_PHYSICAL_ADDRESS)BaseAddress,
                              RShiftU64 (Length + EFI_PAGE_MASK, EFI_PAGE_SHIFT),
                              EFI_MEMORY_UC
                              );
    } else {     */
      EfiAddMemoryDescriptor (
                              NumberOfMemoryMapEntries,
                              EfiMemoryDescriptor,
                              Type,
                              (EFI_PHYSICAL_ADDRESS)(UINTN)BaseAddress,
                              RShiftU64 (Length, EFI_PAGE_SHIFT),
                              Attr
                              );
//    }
  }
  
  //Slice - Add two more descriptors?
  /* dmazar: does not have effect, so removed */
  //Slice - or no! This is only thing that resolves memory KP in SnowLeopard
  //usr-sse2 http://www.projectosx.com/forum/index.php?showtopic=2008&view=findpost&p=13284
  //slice http://www.projectosx.com/forum/index.php?showtopic=2008&view=findpost&p=14702
  //dmazar http://www.projectosx.com/forum/index.php?showtopic=2008&view=findpost&p=16046
  //solution half a year later http://www.projectosx.com/forum/index.php?showtopic=2008&view=findpost&p=16405
  /* 
   before I am proposing 9E000 and 2 page  = 8kb. It is not common case.
  */
  //protect from the EBDA to the 1MB barrier
  EBDAsize = EBDAmax - EBDAaddr;
    
  EfiAddMemoryDescriptor (
                          NumberOfMemoryMapEntries,
                          EfiMemoryDescriptor,
                          EfiReservedMemoryType,
                          (EFI_PHYSICAL_ADDRESS)EBDAaddr,
                          RShiftU64 (EBDAsize + EFI_PAGE_MASK, EFI_PAGE_SHIFT),
                          EFI_MEMORY_UC
                          );
  //EBDA2 protection
/*  EfiAddMemoryDescriptor (
                          NumberOfMemoryMapEntries,
                          EfiMemoryDescriptor,
                          EfiACPIMemoryNVS,
                          (EFI_PHYSICAL_ADDRESS)0x9b000,
                          1,
                          EFI_MEMORY_UC
                          );
*/
  
 // this is just BIOS rom protection. Seems to be not needed.
  /*
  EfiAddMemoryDescriptor (
                          NumberOfMemoryMapEntries,
                          EfiMemoryDescriptor,
                          EfiReservedMemoryType,
                          (EFI_PHYSICAL_ADDRESS)0xE0000,
                          0x20,
                          EFI_MEMORY_UC
                          );
   // */
  
  //
  // Update MemoryMap according to Ceiling
  //
  /* dmazar: Or not?
   * We'll leave BIOS mem map untouched and add those EfiConventionalMemory
   * areas to UEFI mem map in BdsPlatformLib:UpdateMemoryMap().
   *
  for (Index = 0; Index < *NumberOfMemoryMapEntries; Index++) {
    if ((EfiMemoryDescriptor[Index].Type == EfiConventionalMemory) &&
        (EfiMemoryDescriptor[Index].PhysicalStart > 0x100000ULL) && 
        (EfiMemoryDescriptor[Index].PhysicalStart < 0x100000000ULL)) {
      if (EfiMemoryDescriptor[Index].PhysicalStart >= Ceiling){
        EfiMemoryDescriptor[Index].Type = EfiReservedMemoryType;
      }
    }
  }
   */
}