IntelSiliconPkg/Feature/VTd/IntelVTdDxe/DmaProtection.c

   1 /** @file
   2
   3   Copyright (c) 2017 - 2018, Intel Corporation. All rights reserved.<BR>
   4   This program and the accompanying materials
   5   are licensed and made available under the terms and conditions of the BSD License
   6   which accompanies this distribution.  The full text of the license may be found at
   7   http://opensource.org/licenses/bsd-license.php.
   8
   9   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 **/
  13
  14 #include "DmaProtection.h"
  15
  16 UINT64                                  mBelow4GMemoryLimit;
  17 UINT64                                  mAbove4GMemoryLimit;
  18
  19 EDKII_PLATFORM_VTD_POLICY_PROTOCOL      *mPlatformVTdPolicy;
  20
  21 /**
  22   return the UEFI memory information.
  23
  24   @param[out] Below4GMemoryLimit  The below 4GiB memory limit
  25   @param[out] Above4GMemoryLimit  The above 4GiB memory limit
  26 **/
  27 VOID
  28 ReturnUefiMemoryMap (
  29   OUT UINT64   *Below4GMemoryLimit,
  30   OUT UINT64   *Above4GMemoryLimit
  31   )
  32 {
  33   EFI_STATUS                  Status;
  34   EFI_MEMORY_DESCRIPTOR       *EfiMemoryMap;
  35   EFI_MEMORY_DESCRIPTOR       *EfiMemoryMapEnd;
  36   EFI_MEMORY_DESCRIPTOR       *EfiEntry;
  37   EFI_MEMORY_DESCRIPTOR       *NextEfiEntry;
  38   EFI_MEMORY_DESCRIPTOR       TempEfiEntry;
  39   UINTN                       EfiMemoryMapSize;
  40   UINTN                       EfiMapKey;
  41   UINTN                       EfiDescriptorSize;
  42   UINT32                      EfiDescriptorVersion;
  43   UINT64                      MemoryBlockLength;
  44
  45   *Below4GMemoryLimit = 0;
  46   *Above4GMemoryLimit = 0;
  47
  48   //
  49   // Get the EFI memory map.
  50   //
  51   EfiMemoryMapSize  = 0;
  52   EfiMemoryMap      = NULL;
  53   Status = gBS->GetMemoryMap (
  54                   &EfiMemoryMapSize,
  55                   EfiMemoryMap,
  56                   &EfiMapKey,
  57                   &EfiDescriptorSize,
  58                   &EfiDescriptorVersion
  59                   );
  60   ASSERT (Status == EFI_BUFFER_TOO_SMALL);
  61
  62   do {
  63     //
  64     // Use size returned back plus 1 descriptor for the AllocatePool.
  65     // We don't just multiply by 2 since the "for" loop below terminates on
  66     // EfiMemoryMapEnd which is dependent upon EfiMemoryMapSize. Otherwize
  67     // we process bogus entries and create bogus E820 entries.
  68     //
  69     EfiMemoryMap = (EFI_MEMORY_DESCRIPTOR *) AllocatePool (EfiMemoryMapSize);
  70     ASSERT (EfiMemoryMap != NULL);
  71     Status = gBS->GetMemoryMap (
  72                     &EfiMemoryMapSize,
  73                     EfiMemoryMap,
  74                     &EfiMapKey,
  75                     &EfiDescriptorSize,
  76                     &EfiDescriptorVersion
  77                     );
  78     if (EFI_ERROR (Status)) {
  79       FreePool (EfiMemoryMap);
  80     }
  81   } while (Status == EFI_BUFFER_TOO_SMALL);
  82
  83   ASSERT_EFI_ERROR (Status);
  84
  85   //
  86   // Sort memory map from low to high
  87   //
  88   EfiEntry        = EfiMemoryMap;
  89   NextEfiEntry    = NEXT_MEMORY_DESCRIPTOR (EfiEntry, EfiDescriptorSize);
  90   EfiMemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) EfiMemoryMap + EfiMemoryMapSize);
  91   while (EfiEntry < EfiMemoryMapEnd) {
  92     while (NextEfiEntry < EfiMemoryMapEnd) {
  93       if (EfiEntry->PhysicalStart > NextEfiEntry->PhysicalStart) {
  94         CopyMem (&TempEfiEntry, EfiEntry, sizeof (EFI_MEMORY_DESCRIPTOR));
  95         CopyMem (EfiEntry, NextEfiEntry, sizeof (EFI_MEMORY_DESCRIPTOR));
  96         CopyMem (NextEfiEntry, &TempEfiEntry, sizeof (EFI_MEMORY_DESCRIPTOR));
  97       }
  98
  99       NextEfiEntry = NEXT_MEMORY_DESCRIPTOR (NextEfiEntry, EfiDescriptorSize);
 100     }
 101
 102     EfiEntry      = NEXT_MEMORY_DESCRIPTOR (EfiEntry, EfiDescriptorSize);
 103     NextEfiEntry  = NEXT_MEMORY_DESCRIPTOR (EfiEntry, EfiDescriptorSize);
 104   }
 105
 106   //
 107   //
 108   //
 109   DEBUG ((DEBUG_INFO, "MemoryMap:\n"));
 110   EfiEntry        = EfiMemoryMap;
 111   EfiMemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) EfiMemoryMap + EfiMemoryMapSize);
 112   while (EfiEntry < EfiMemoryMapEnd) {
 113     MemoryBlockLength = (UINT64) (LShiftU64 (EfiEntry->NumberOfPages, 12));
 114     DEBUG ((DEBUG_INFO, "Entry(0x%02x) 0x%016lx - 0x%016lx\n", EfiEntry->Type, EfiEntry->PhysicalStart, EfiEntry->PhysicalStart + MemoryBlockLength));
 115     switch (EfiEntry->Type) {
 116     case EfiLoaderCode:
 117     case EfiLoaderData:
 118     case EfiBootServicesCode:
 119     case EfiBootServicesData:
 120     case EfiConventionalMemory:
 121     case EfiRuntimeServicesCode:
 122     case EfiRuntimeServicesData:
 123     case EfiACPIReclaimMemory:
 124     case EfiACPIMemoryNVS:
 125     case EfiReservedMemoryType:
 126       if ((EfiEntry->PhysicalStart + MemoryBlockLength) <= BASE_1MB) {
 127         //
 128         // Skip the memory block is under 1MB
 129         //
 130       } else if (EfiEntry->PhysicalStart >= BASE_4GB) {
 131         if (*Above4GMemoryLimit < EfiEntry->PhysicalStart + MemoryBlockLength) {
 132           *Above4GMemoryLimit = EfiEntry->PhysicalStart + MemoryBlockLength;
 133         }
 134       } else {
 135         if (*Below4GMemoryLimit < EfiEntry->PhysicalStart + MemoryBlockLength) {
 136           *Below4GMemoryLimit = EfiEntry->PhysicalStart + MemoryBlockLength;
 137         }
 138       }
 139       break;
 140     }
 141     EfiEntry = NEXT_MEMORY_DESCRIPTOR (EfiEntry, EfiDescriptorSize);
 142   }
 143
 144   FreePool (EfiMemoryMap);
 145
 146   DEBUG ((DEBUG_INFO, "Result:\n"));
 147   DEBUG ((DEBUG_INFO, "Below4GMemoryLimit:  0x%016lx\n", *Below4GMemoryLimit));
 148   DEBUG ((DEBUG_INFO, "Above4GMemoryLimit:  0x%016lx\n", *Above4GMemoryLimit));
 149
 150   return ;
 151 }
 152
 153 /**
 154   The scan bus callback function to always enable page attribute.
 155
 156   @param[in]  Context               The context of the callback.
 157   @param[in]  Segment               The segment of the source.
 158   @param[in]  Bus                   The bus of the source.
 159   @param[in]  Device                The device of the source.
 160   @param[in]  Function              The function of the source.
 161
 162   @retval EFI_SUCCESS           The VTd entry is updated to always enable all DMA access for the specific device.
 163 **/
 164 EFI_STATUS
 165 EFIAPI
 166 ScanBusCallbackAlwaysEnablePageAttribute (
 167   IN VOID           *Context,
 168   IN UINT16         Segment,
 169   IN UINT8          Bus,
 170   IN UINT8          Device,
 171   IN UINT8          Function
 172   )
 173 {
 174   VTD_SOURCE_ID           SourceId;
 175   EFI_STATUS              Status;
 176
 177   SourceId.Bits.Bus = Bus;
 178   SourceId.Bits.Device = Device;
 179   SourceId.Bits.Function = Function;
 180   Status = AlwaysEnablePageAttribute (Segment, SourceId);
 181   return Status;
 182 }
 183
 184 /**
 185   Always enable the VTd page attribute for the device in the DeviceScope.
 186
 187   @param[in]  DeviceScope  the input device scope data structure
 188
 189   @retval EFI_SUCCESS           The VTd entry is updated to always enable all DMA access for the specific device in the device scope.
 190 **/
 191 EFI_STATUS
 192 AlwaysEnablePageAttributeDeviceScope (
 193   IN  EDKII_PLATFORM_VTD_DEVICE_SCOPE   *DeviceScope
 194   )
 195 {
 196   UINT8                             Bus;
 197   UINT8                             Device;
 198   UINT8                             Function;
 199   VTD_SOURCE_ID                     SourceId;
 200   UINT8                             SecondaryBusNumber;
 201   EFI_STATUS                        Status;
 202
 203   Status = GetPciBusDeviceFunction (DeviceScope->SegmentNumber, &DeviceScope->DeviceScope, &Bus, &Device, &Function);
 204
 205   if (DeviceScope->DeviceScope.Type == EFI_ACPI_DEVICE_SCOPE_ENTRY_TYPE_PCI_BRIDGE) {
 206     //
 207     // Need scan the bridge and add all devices.
 208     //
 209     SecondaryBusNumber = PciSegmentRead8 (PCI_SEGMENT_LIB_ADDRESS(DeviceScope->SegmentNumber, Bus, Device, Function, PCI_BRIDGE_SECONDARY_BUS_REGISTER_OFFSET));
 210     Status = ScanPciBus (NULL, DeviceScope->SegmentNumber, SecondaryBusNumber, ScanBusCallbackAlwaysEnablePageAttribute);
 211     return Status;
 212   } else {
 213     SourceId.Bits.Bus      = Bus;
 214     SourceId.Bits.Device   = Device;
 215     SourceId.Bits.Function = Function;
 216     Status = AlwaysEnablePageAttribute (DeviceScope->SegmentNumber, SourceId);
 217     return Status;
 218   }
 219 }
 220
 221 /**
 222   Always enable the VTd page attribute for the device matching DeviceId.
 223
 224   @param[in]  PciDeviceId  the input PCI device ID
 225
 226   @retval EFI_SUCCESS           The VTd entry is updated to always enable all DMA access for the specific device matching DeviceId.
 227 **/
 228 EFI_STATUS
 229 AlwaysEnablePageAttributePciDeviceId (
 230   IN  EDKII_PLATFORM_VTD_PCI_DEVICE_ID   *PciDeviceId
 231   )
 232 {
 233   UINTN            VtdIndex;
 234   UINTN            PciIndex;
 235   PCI_DEVICE_DATA  *PciDeviceData;
 236   EFI_STATUS       Status;
 237
 238   for (VtdIndex = 0; VtdIndex < mVtdUnitNumber; VtdIndex++) {
 239     for (PciIndex = 0; PciIndex < mVtdUnitInformation[VtdIndex].PciDeviceInfo.PciDeviceDataNumber; PciIndex++) {
 240       PciDeviceData = &mVtdUnitInformation[VtdIndex].PciDeviceInfo.PciDeviceData[PciIndex];
 241
 242       if (((PciDeviceId->VendorId == 0xFFFF) || (PciDeviceId->VendorId == PciDeviceData->PciDeviceId.VendorId)) &&
 243           ((PciDeviceId->DeviceId == 0xFFFF) || (PciDeviceId->DeviceId == PciDeviceData->PciDeviceId.DeviceId)) &&
 244           ((PciDeviceId->RevisionId == 0xFF) || (PciDeviceId->RevisionId == PciDeviceData->PciDeviceId.RevisionId)) &&
 245           ((PciDeviceId->SubsystemVendorId == 0xFFFF) || (PciDeviceId->SubsystemVendorId == PciDeviceData->PciDeviceId.SubsystemVendorId)) &&
 246           ((PciDeviceId->SubsystemDeviceId == 0xFFFF) || (PciDeviceId->SubsystemDeviceId == PciDeviceData->PciDeviceId.SubsystemDeviceId)) ) {
 247         Status = AlwaysEnablePageAttribute (mVtdUnitInformation[VtdIndex].Segment, PciDeviceData->PciSourceId);
 248         if (EFI_ERROR(Status)) {
 249           continue;
 250         }
 251       }
 252     }
 253   }
 254   return EFI_SUCCESS;
 255 }
 256
 257 /**
 258   Always enable the VTd page attribute for the device.
 259
 260   @param[in]  DeviceInfo  the exception device information
 261
 262   @retval EFI_SUCCESS           The VTd entry is updated to always enable all DMA access for the specific device in the device info.
 263 **/
 264 EFI_STATUS
 265 AlwaysEnablePageAttributeExceptionDeviceInfo (
 266   IN  EDKII_PLATFORM_VTD_EXCEPTION_DEVICE_INFO   *DeviceInfo
 267   )
 268 {
 269   switch (DeviceInfo->Type) {
 270   case EDKII_PLATFORM_VTD_EXCEPTION_DEVICE_INFO_TYPE_DEVICE_SCOPE:
 271     return AlwaysEnablePageAttributeDeviceScope ((VOID *)(DeviceInfo + 1));
 272   case EDKII_PLATFORM_VTD_EXCEPTION_DEVICE_INFO_TYPE_PCI_DEVICE_ID:
 273     return AlwaysEnablePageAttributePciDeviceId ((VOID *)(DeviceInfo + 1));
 274   default:
 275     return EFI_UNSUPPORTED;
 276   }
 277 }
 278
 279 /**
 280   Initialize platform VTd policy.
 281 **/
 282 VOID
 283 InitializePlatformVTdPolicy (
 284   VOID
 285   )
 286 {
 287   EFI_STATUS                               Status;
 288   UINTN                                    DeviceInfoCount;
 289   VOID                                     *DeviceInfo;
 290   EDKII_PLATFORM_VTD_EXCEPTION_DEVICE_INFO *ThisDeviceInfo;
 291   UINTN                                    Index;
 292
 293   //
 294   // It is optional.
 295   //
 296   Status = gBS->LocateProtocol (
 297                   &gEdkiiPlatformVTdPolicyProtocolGuid,
 298                   NULL,
 299                   (VOID **)&mPlatformVTdPolicy
 300                   );
 301   if (!EFI_ERROR(Status)) {
 302     DEBUG ((DEBUG_INFO, "InitializePlatformVTdPolicy\n"));
 303     Status = mPlatformVTdPolicy->GetExceptionDeviceList (mPlatformVTdPolicy, &DeviceInfoCount, &DeviceInfo);
 304     if (!EFI_ERROR(Status)) {
 305       ThisDeviceInfo = DeviceInfo;
 306       for (Index = 0; Index < DeviceInfoCount; Index++) {
 307         if (ThisDeviceInfo->Type == EDKII_PLATFORM_VTD_EXCEPTION_DEVICE_INFO_TYPE_END) {
 308           break;
 309         }
 310         AlwaysEnablePageAttributeExceptionDeviceInfo (ThisDeviceInfo);
 311         ThisDeviceInfo = (VOID *)((UINTN)ThisDeviceInfo + ThisDeviceInfo->Length);
 312       }
 313       FreePool (DeviceInfo);
 314     }
 315   }
 316 }
 317
 318 /**
 319   Setup VTd engine.
 320 **/
 321 VOID
 322 SetupVtd (
 323   VOID
 324   )
 325 {
 326   EFI_STATUS      Status;
 327   VOID            *PciEnumerationComplete;
 328   UINTN           Index;
 329   UINT64          Below4GMemoryLimit;
 330   UINT64          Above4GMemoryLimit;
 331
 332   //
 333   // PCI Enumeration must be done
 334   //
 335   Status = gBS->LocateProtocol (
 336                   &gEfiPciEnumerationCompleteProtocolGuid,
 337                   NULL,
 338                   &PciEnumerationComplete
 339                   );
 340   ASSERT_EFI_ERROR (Status);
 341
 342   ReturnUefiMemoryMap (&Below4GMemoryLimit, &Above4GMemoryLimit);
 343   Below4GMemoryLimit = ALIGN_VALUE_UP(Below4GMemoryLimit, SIZE_256MB);
 344   DEBUG ((DEBUG_INFO, " Adjusted Below4GMemoryLimit: 0x%016lx\n", Below4GMemoryLimit));
 345
 346   mBelow4GMemoryLimit = Below4GMemoryLimit;
 347   mAbove4GMemoryLimit = Above4GMemoryLimit;
 348
 349   //
 350   // 1. setup
 351   //
 352   DEBUG ((DEBUG_INFO, "ParseDmarAcpiTable\n"));
 353   Status = ParseDmarAcpiTableDrhd ();
 354   if (EFI_ERROR (Status)) {
 355     return;
 356   }
 357   DEBUG ((DEBUG_INFO, "PrepareVtdConfig\n"));
 358   PrepareVtdConfig ();
 359
 360   //
 361   // 2. initialization
 362   //
 363   DEBUG ((DEBUG_INFO, "SetupTranslationTable\n"));
 364   Status = SetupTranslationTable ();
 365   if (EFI_ERROR (Status)) {
 366     return;
 367   }
 368
 369   InitializePlatformVTdPolicy ();
 370
 371   ParseDmarAcpiTableRmrr ();
 372
 373   for (Index = 0; Index < mVtdUnitNumber; Index++) {
 374     DEBUG ((DEBUG_INFO,"VTD Unit %d (Segment: %04x)\n", Index, mVtdUnitInformation[Index].Segment));
 375     if (mVtdUnitInformation[Index].ExtRootEntryTable != NULL) {
 376       DumpDmarExtContextEntryTable (mVtdUnitInformation[Index].ExtRootEntryTable);
 377     }
 378     if (mVtdUnitInformation[Index].RootEntryTable != NULL) {
 379       DumpDmarContextEntryTable (mVtdUnitInformation[Index].RootEntryTable);
 380     }
 381   }
 382
 383   //
 384   // 3. enable
 385   //
 386   DEBUG ((DEBUG_INFO, "EnableDmar\n"));
 387   Status = EnableDmar ();
 388   if (EFI_ERROR (Status)) {
 389     return;
 390   }
 391   DEBUG ((DEBUG_INFO, "DumpVtdRegs\n"));
 392   DumpVtdRegsAll ();
 393 }
 394
 395 /**
 396   Notification function of ACPI Table change.
 397
 398   This is a notification function registered on ACPI Table change event.
 399
 400   @param  Event        Event whose notification function is being invoked.
 401   @param  Context      Pointer to the notification function's context.
 402
 403 **/
 404 VOID
 405 EFIAPI
 406 AcpiNotificationFunc (
 407   IN EFI_EVENT        Event,
 408   IN VOID             *Context
 409   )
 410 {
 411   EFI_STATUS          Status;
 412
 413   Status = GetDmarAcpiTable ();
 414   if (EFI_ERROR (Status)) {
 415     if (Status == EFI_ALREADY_STARTED) {
 416       gBS->CloseEvent (Event);
 417     }
 418     return;
 419   }
 420   SetupVtd ();
 421   gBS->CloseEvent (Event);
 422 }
 423
 424 /**
 425   Exit boot service callback function.
 426
 427   @param[in]  Event    The event handle.
 428   @param[in]  Context  The event content.
 429 **/
 430 VOID
 431 EFIAPI
 432 OnExitBootServices (
 433   IN EFI_EVENT                               Event,
 434   IN VOID                                    *Context
 435   )
 436 {
 437   DEBUG ((DEBUG_INFO, "Vtd OnExitBootServices\n"));
 438   DumpVtdRegsAll ();
 439
 440   if ((PcdGet8(PcdVTdPolicyPropertyMask) & BIT1) == 0) {
 441     DisableDmar ();
 442     DumpVtdRegsAll ();
 443   }
 444 }
 445
 446 /**
 447   Legacy boot callback function.
 448
 449   @param[in]  Event    The event handle.
 450   @param[in]  Context  The event content.
 451 **/
 452 VOID
 453 EFIAPI
 454 OnLegacyBoot (
 455   EFI_EVENT                               Event,
 456   VOID                                    *Context
 457   )
 458 {
 459   DEBUG ((DEBUG_INFO, "Vtd OnLegacyBoot\n"));
 460   DumpVtdRegsAll ();
 461   DisableDmar ();
 462   DumpVtdRegsAll ();
 463 }
 464
 465 /**
 466   Initialize DMA protection.
 467 **/
 468 VOID
 469 InitializeDmaProtection (
 470   VOID
 471   )
 472 {
 473   EFI_STATUS  Status;
 474   EFI_EVENT   ExitBootServicesEvent;
 475   EFI_EVENT   LegacyBootEvent;
 476   EFI_EVENT   EventAcpi10;
 477   EFI_EVENT   EventAcpi20;
 478
 479   Status = gBS->CreateEventEx (
 480                   EVT_NOTIFY_SIGNAL,
 481                   VTD_TPL_LEVEL,
 482                   AcpiNotificationFunc,
 483                   NULL,
 484                   &gEfiAcpi10TableGuid,
 485                   &EventAcpi10
 486                   );
 487   ASSERT_EFI_ERROR (Status);
 488
 489   Status = gBS->CreateEventEx (
 490                   EVT_NOTIFY_SIGNAL,
 491                   VTD_TPL_LEVEL,
 492                   AcpiNotificationFunc,
 493                   NULL,
 494                   &gEfiAcpi20TableGuid,
 495                   &EventAcpi20
 496                   );
 497   ASSERT_EFI_ERROR (Status);
 498
 499   //
 500   // Signal the events initially for the case
 501   // that DMAR table has been installed.
 502   //
 503   gBS->SignalEvent (EventAcpi20);
 504   gBS->SignalEvent (EventAcpi10);
 505
 506   Status = gBS->CreateEventEx (
 507                   EVT_NOTIFY_SIGNAL,
 508                   TPL_CALLBACK,
 509                   OnExitBootServices,
 510                   NULL,
 511                   &gEfiEventExitBootServicesGuid,
 512                   &ExitBootServicesEvent
 513                   );
 514   ASSERT_EFI_ERROR (Status);
 515
 516   Status = EfiCreateEventLegacyBootEx (
 517              TPL_CALLBACK,
 518              OnLegacyBoot,
 519              NULL,
 520              &LegacyBootEvent
 521              );
 522   ASSERT_EFI_ERROR (Status);
 523
 524   return ;
 525 }