MdeModulePkg/Core/PiSmmCore/PiSmmCore.h

   1 /** @file
   2   The internal header file includes the common header files, defines
   3   internal structure and functions used by SmmCore module.
   4
   5   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
   6   This program and the accompanying materials are licensed and made available
   7   under the terms and conditions of the BSD License which accompanies this
   8   distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #ifndef _SMM_CORE_H_
  17 #define _SMM_CORE_H_
  18
  19 #include <PiSmm.h>
  20
  21 #include <Protocol/DxeSmmReadyToLock.h>
  22 #include <Protocol/SmmReadyToLock.h>
  23 #include <Protocol/CpuIo2.h>
  24 #include <Protocol/SmmCommunication.h>
  25 #include <Protocol/SmmAccess2.h>
  26 #include <Protocol/FirmwareVolume2.h>
  27 #include <Protocol/LoadedImage.h>
  28 #include <Protocol/DevicePath.h>
  29 #include <Protocol/Security.h>
  30
  31 #include <Guid/Apriori.h>
  32 #include <Guid/EventGroup.h>
  33 #include <Guid/EventLegacyBios.h>
  34
  35 #include <Library/BaseLib.h>
  36 #include <Library/BaseMemoryLib.h>
  37 #include <Library/PeCoffLib.h>
  38 #include <Library/CacheMaintenanceLib.h>
  39 #include <Library/DebugLib.h>
  40 #include <Library/ReportStatusCodeLib.h>
  41 #include <Library/MemoryAllocationLib.h>
  42 #include <Library/DevicePathLib.h>
  43 #include <Library/UefiLib.h>
  44 #include <Library/UefiBootServicesTableLib.h>
  45 #include <Library/PcdLib.h>
  46 #include <Library/SmmCorePlatformHookLib.h>
  47 #include <Library/PerformanceLib.h>
  48
  49 #include "PiSmmCorePrivateData.h"
  50
  51 //
  52 // Used to build a table of SMI Handlers that the SMM Core registers
  53 //
  54 typedef struct {
  55   EFI_SMM_HANDLER_ENTRY_POINT2  Handler;
  56   EFI_GUID                      *HandlerType;
  57   EFI_HANDLE                    DispatchHandle;
  58   BOOLEAN                       UnRegister;
  59 } SMM_CORE_SMI_HANDLERS;
  60
  61 //
  62 // Structure for recording the state of an SMM Driver
  63 //
  64 #define EFI_SMM_DRIVER_ENTRY_SIGNATURE SIGNATURE_32('s', 'd','r','v')
  65
  66 typedef struct {
  67   UINTN                           Signature;
  68   LIST_ENTRY                      Link;             // mDriverList
  69
  70   LIST_ENTRY                      ScheduledLink;    // mScheduledQueue
  71
  72   EFI_HANDLE                      FvHandle;
  73   EFI_GUID                        FileName;
  74   EFI_DEVICE_PATH_PROTOCOL        *FvFileDevicePath;
  75   EFI_FIRMWARE_VOLUME2_PROTOCOL   *Fv;
  76
  77   VOID                            *Depex;
  78   UINTN                           DepexSize;
  79
  80   BOOLEAN                         Before;
  81   BOOLEAN                         After;
  82   EFI_GUID                        BeforeAfterGuid;
  83
  84   BOOLEAN                         Dependent;
  85   BOOLEAN                         Scheduled;
  86   BOOLEAN                         Initialized;
  87   BOOLEAN                         DepexProtocolError;
  88
  89   EFI_HANDLE                      ImageHandle;
  90   EFI_LOADED_IMAGE_PROTOCOL       *LoadedImage;
  91   //
  92   // Image EntryPoint in SMRAM
  93   //
  94   PHYSICAL_ADDRESS                ImageEntryPoint;
  95   //
  96   // Image Buffer in SMRAM
  97   //
  98   PHYSICAL_ADDRESS                ImageBuffer;
  99   //
 100   // Image Page Number
 101   //
 102   UINTN                           NumberOfPage;
 103 } EFI_SMM_DRIVER_ENTRY;
 104
 105 #define EFI_HANDLE_SIGNATURE            SIGNATURE_32('h','n','d','l')
 106
 107 ///
 108 /// IHANDLE - contains a list of protocol handles
 109 ///
 110 typedef struct {
 111   UINTN               Signature;
 112   /// All handles list of IHANDLE
 113   LIST_ENTRY          AllHandles;
 114   /// List of PROTOCOL_INTERFACE's for this handle
 115   LIST_ENTRY          Protocols;
 116   UINTN               LocateRequest;
 117 } IHANDLE;
 118
 119 #define ASSERT_IS_HANDLE(a)  ASSERT((a)->Signature == EFI_HANDLE_SIGNATURE)
 120
 121 #define PROTOCOL_ENTRY_SIGNATURE        SIGNATURE_32('p','r','t','e')
 122
 123 ///
 124 /// PROTOCOL_ENTRY - each different protocol has 1 entry in the protocol
 125 /// database.  Each handler that supports this protocol is listed, along
 126 /// with a list of registered notifies.
 127 ///
 128 typedef struct {
 129   UINTN               Signature;
 130   /// Link Entry inserted to mProtocolDatabase
 131   LIST_ENTRY          AllEntries;
 132   /// ID of the protocol
 133   EFI_GUID            ProtocolID;
 134   /// All protocol interfaces
 135   LIST_ENTRY          Protocols;
 136   /// Registerd notification handlers
 137   LIST_ENTRY          Notify;
 138 } PROTOCOL_ENTRY;
 139
 140 #define PROTOCOL_INTERFACE_SIGNATURE  SIGNATURE_32('p','i','f','c')
 141
 142 ///
 143 /// PROTOCOL_INTERFACE - each protocol installed on a handle is tracked
 144 /// with a protocol interface structure
 145 ///
 146 typedef struct {
 147   UINTN                       Signature;
 148   /// Link on IHANDLE.Protocols
 149   LIST_ENTRY                  Link;
 150   /// Back pointer
 151   IHANDLE                     *Handle;
 152   /// Link on PROTOCOL_ENTRY.Protocols
 153   LIST_ENTRY                  ByProtocol;
 154   /// The protocol ID
 155   PROTOCOL_ENTRY              *Protocol;
 156   /// The interface value
 157   VOID                        *Interface;
 158 } PROTOCOL_INTERFACE;
 159
 160 #define PROTOCOL_NOTIFY_SIGNATURE       SIGNATURE_32('p','r','t','n')
 161
 162 ///
 163 /// PROTOCOL_NOTIFY - used for each register notification for a protocol
 164 ///
 165 typedef struct {
 166   UINTN               Signature;
 167   PROTOCOL_ENTRY      *Protocol;
 168   /// All notifications for this protocol
 169   LIST_ENTRY          Link;
 170   /// Notification function
 171   EFI_SMM_NOTIFY_FN   Function;
 172   /// Last position notified
 173   LIST_ENTRY          *Position;
 174 } PROTOCOL_NOTIFY;
 175
 176 //
 177 // SMM Core Global Variables
 178 //
 179 extern SMM_CORE_PRIVATE_DATA  *gSmmCorePrivate;
 180 extern EFI_SMM_SYSTEM_TABLE2  gSmmCoreSmst;
 181 extern LIST_ENTRY             gHandleList;
 182 extern EFI_PHYSICAL_ADDRESS   gLoadModuleAtFixAddressSmramBase;
 183
 184 /**
 185   Called to initialize the memory service.
 186
 187   @param   SmramRangeCount       Number of SMRAM Regions
 188   @param   SmramRanges           Pointer to SMRAM Descriptors
 189
 190 **/
 191 VOID
 192 SmmInitializeMemoryServices (
 193   IN UINTN                 SmramRangeCount,
 194   IN EFI_SMRAM_DESCRIPTOR  *SmramRanges
 195   );
 196
 197 /**
 198   The SmmInstallConfigurationTable() function is used to maintain the list
 199   of configuration tables that are stored in the System Management System
 200   Table.  The list is stored as an array of (GUID, Pointer) pairs.  The list
 201   must be allocated from pool memory with PoolType set to EfiRuntimeServicesData.
 202
 203   @param  SystemTable      A pointer to the SMM System Table (SMST).
 204   @param  Guid             A pointer to the GUID for the entry to add, update, or remove.
 205   @param  Table            A pointer to the buffer of the table to add.
 206   @param  TableSize        The size of the table to install.
 207
 208   @retval EFI_SUCCESS           The (Guid, Table) pair was added, updated, or removed.
 209   @retval EFI_INVALID_PARAMETER Guid is not valid.
 210   @retval EFI_NOT_FOUND         An attempt was made to delete a non-existent entry.
 211   @retval EFI_OUT_OF_RESOURCES  There is not enough memory available to complete the operation.
 212
 213 **/
 214 EFI_STATUS
 215 EFIAPI
 216 SmmInstallConfigurationTable (
 217   IN  CONST EFI_SMM_SYSTEM_TABLE2  *SystemTable,
 218   IN  CONST EFI_GUID              *Guid,
 219   IN  VOID                        *Table,
 220   IN  UINTN                       TableSize
 221   );
 222
 223 /**
 224   Wrapper function to SmmInstallProtocolInterfaceNotify.  This is the public API which
 225   Calls the private one which contains a BOOLEAN parameter for notifications
 226
 227   @param  UserHandle             The handle to install the protocol handler on,
 228                                  or NULL if a new handle is to be allocated
 229   @param  Protocol               The protocol to add to the handle
 230   @param  InterfaceType          Indicates whether Interface is supplied in
 231                                  native form.
 232   @param  Interface              The interface for the protocol being added
 233
 234   @return Status code
 235
 236 **/
 237 EFI_STATUS
 238 EFIAPI
 239 SmmInstallProtocolInterface (
 240   IN OUT EFI_HANDLE     *UserHandle,
 241   IN EFI_GUID           *Protocol,
 242   IN EFI_INTERFACE_TYPE InterfaceType,
 243   IN VOID               *Interface
 244   );
 245
 246 /**
 247   Allocates pages from the memory map.
 248
 249   @param  Type                   The type of allocation to perform
 250   @param  MemoryType             The type of memory to turn the allocated pages
 251                                  into
 252   @param  NumberOfPages          The number of pages to allocate
 253   @param  Memory                 A pointer to receive the base allocated memory
 254                                  address
 255
 256   @retval EFI_INVALID_PARAMETER  Parameters violate checking rules defined in spec.
 257   @retval EFI_NOT_FOUND          Could not allocate pages match the requirement.
 258   @retval EFI_OUT_OF_RESOURCES   No enough pages to allocate.
 259   @retval EFI_SUCCESS            Pages successfully allocated.
 260
 261 **/
 262 EFI_STATUS
 263 EFIAPI
 264 SmmAllocatePages (
 265   IN      EFI_ALLOCATE_TYPE         Type,
 266   IN      EFI_MEMORY_TYPE           MemoryType,
 267   IN      UINTN                     NumberOfPages,
 268   OUT     EFI_PHYSICAL_ADDRESS      *Memory
 269   );
 270
 271 /**
 272   Frees previous allocated pages.
 273
 274   @param  Memory                 Base address of memory being freed
 275   @param  NumberOfPages          The number of pages to free
 276
 277   @retval EFI_NOT_FOUND          Could not find the entry that covers the range
 278   @retval EFI_INVALID_PARAMETER  Address not aligned
 279   @return EFI_SUCCESS            Pages successfully freed.
 280
 281 **/
 282 EFI_STATUS
 283 EFIAPI
 284 SmmFreePages (
 285   IN      EFI_PHYSICAL_ADDRESS      Memory,
 286   IN      UINTN                     NumberOfPages
 287   );
 288
 289 /**
 290   Allocate pool of a particular type.
 291
 292   @param  PoolType               Type of pool to allocate
 293   @param  Size                   The amount of pool to allocate
 294   @param  Buffer                 The address to return a pointer to the allocated
 295                                  pool
 296
 297   @retval EFI_INVALID_PARAMETER  PoolType not valid
 298   @retval EFI_OUT_OF_RESOURCES   Size exceeds max pool size or allocation failed.
 299   @retval EFI_SUCCESS            Pool successfully allocated.
 300
 301 **/
 302 EFI_STATUS
 303 EFIAPI
 304 SmmAllocatePool (
 305   IN      EFI_MEMORY_TYPE           PoolType,
 306   IN      UINTN                     Size,
 307   OUT     VOID                      **Buffer
 308   );
 309
 310 /**
 311   Frees pool.
 312
 313   @param  Buffer                 The allocated pool entry to free
 314
 315   @retval EFI_INVALID_PARAMETER  Buffer is not a valid value.
 316   @retval EFI_SUCCESS            Pool successfully freed.
 317
 318 **/
 319 EFI_STATUS
 320 EFIAPI
 321 SmmFreePool (
 322   IN      VOID                      *Buffer
 323   );
 324
 325 /**
 326   Installs a protocol interface into the boot services environment.
 327
 328   @param  UserHandle             The handle to install the protocol handler on,
 329                                  or NULL if a new handle is to be allocated
 330   @param  Protocol               The protocol to add to the handle
 331   @param  InterfaceType          Indicates whether Interface is supplied in
 332                                  native form.
 333   @param  Interface              The interface for the protocol being added
 334   @param  Notify                 indicates whether notify the notification list
 335                                  for this protocol
 336
 337   @retval EFI_INVALID_PARAMETER  Invalid parameter
 338   @retval EFI_OUT_OF_RESOURCES   No enough buffer to allocate
 339   @retval EFI_SUCCESS            Protocol interface successfully installed
 340
 341 **/
 342 EFI_STATUS
 343 SmmInstallProtocolInterfaceNotify (
 344   IN OUT EFI_HANDLE     *UserHandle,
 345   IN EFI_GUID           *Protocol,
 346   IN EFI_INTERFACE_TYPE InterfaceType,
 347   IN VOID               *Interface,
 348   IN BOOLEAN            Notify
 349   );
 350
 351 /**
 352   Uninstalls all instances of a protocol:interfacer from a handle.
 353   If the last protocol interface is remove from the handle, the
 354   handle is freed.
 355
 356   @param  UserHandle             The handle to remove the protocol handler from
 357   @param  Protocol               The protocol, of protocol:interface, to remove
 358   @param  Interface              The interface, of protocol:interface, to remove
 359
 360   @retval EFI_INVALID_PARAMETER  Protocol is NULL.
 361   @retval EFI_SUCCESS            Protocol interface successfully uninstalled.
 362
 363 **/
 364 EFI_STATUS
 365 EFIAPI
 366 SmmUninstallProtocolInterface (
 367   IN EFI_HANDLE       UserHandle,
 368   IN EFI_GUID         *Protocol,
 369   IN VOID             *Interface
 370   );
 371
 372 /**
 373   Queries a handle to determine if it supports a specified protocol.
 374
 375   @param  UserHandle             The handle being queried.
 376   @param  Protocol               The published unique identifier of the protocol.
 377   @param  Interface              Supplies the address where a pointer to the
 378                                  corresponding Protocol Interface is returned.
 379
 380   @return The requested protocol interface for the handle
 381
 382 **/
 383 EFI_STATUS
 384 EFIAPI
 385 SmmHandleProtocol (
 386   IN EFI_HANDLE       UserHandle,
 387   IN EFI_GUID         *Protocol,
 388   OUT VOID            **Interface
 389   );
 390
 391 /**
 392   Add a new protocol notification record for the request protocol.
 393
 394   @param  Protocol               The requested protocol to add the notify
 395                                  registration
 396   @param  Function               Points to the notification function
 397   @param  Registration           Returns the registration record
 398
 399   @retval EFI_INVALID_PARAMETER  Invalid parameter
 400   @retval EFI_SUCCESS            Successfully returned the registration record
 401                                  that has been added
 402
 403 **/
 404 EFI_STATUS
 405 EFIAPI
 406 SmmRegisterProtocolNotify (
 407   IN  CONST EFI_GUID              *Protocol,
 408   IN  EFI_SMM_NOTIFY_FN           Function,
 409   OUT VOID                        **Registration
 410   );
 411
 412 /**
 413   Locates the requested handle(s) and returns them in Buffer.
 414
 415   @param  SearchType             The type of search to perform to locate the
 416                                  handles
 417   @param  Protocol               The protocol to search for
 418   @param  SearchKey              Dependant on SearchType
 419   @param  BufferSize             On input the size of Buffer.  On output the
 420                                  size of data returned.
 421   @param  Buffer                 The buffer to return the results in
 422
 423   @retval EFI_BUFFER_TOO_SMALL   Buffer too small, required buffer size is
 424                                  returned in BufferSize.
 425   @retval EFI_INVALID_PARAMETER  Invalid parameter
 426   @retval EFI_SUCCESS            Successfully found the requested handle(s) and
 427                                  returns them in Buffer.
 428
 429 **/
 430 EFI_STATUS
 431 EFIAPI
 432 SmmLocateHandle (
 433   IN EFI_LOCATE_SEARCH_TYPE   SearchType,
 434   IN EFI_GUID                 *Protocol   OPTIONAL,
 435   IN VOID                     *SearchKey  OPTIONAL,
 436   IN OUT UINTN                *BufferSize,
 437   OUT EFI_HANDLE              *Buffer
 438   );
 439
 440 /**
 441   Return the first Protocol Interface that matches the Protocol GUID. If
 442   Registration is pasased in return a Protocol Instance that was just add
 443   to the system. If Retistration is NULL return the first Protocol Interface
 444   you find.
 445
 446   @param  Protocol               The protocol to search for
 447   @param  Registration           Optional Registration Key returned from
 448                                  RegisterProtocolNotify()
 449   @param  Interface              Return the Protocol interface (instance).
 450
 451   @retval EFI_SUCCESS            If a valid Interface is returned
 452   @retval EFI_INVALID_PARAMETER  Invalid parameter
 453   @retval EFI_NOT_FOUND          Protocol interface not found
 454
 455 **/
 456 EFI_STATUS
 457 EFIAPI
 458 SmmLocateProtocol (
 459   IN  EFI_GUID  *Protocol,
 460   IN  VOID      *Registration OPTIONAL,
 461   OUT VOID      **Interface
 462   );
 463
 464 /**
 465   Manage SMI of a particular type.
 466
 467   @param  HandlerType    Points to the handler type or NULL for root SMI handlers.
 468   @param  Context        Points to an optional context buffer.
 469   @param  CommBuffer     Points to the optional communication buffer.
 470   @param  CommBufferSize Points to the size of the optional communication buffer.
 471
 472   @retval EFI_SUCCESS                        Interrupt source was processed successfully but not quiesced.
 473   @retval EFI_INTERRUPT_PENDING              One or more SMI sources could not be quiesced.
 474   @retval EFI_WARN_INTERRUPT_SOURCE_PENDING  Interrupt source was not handled or quiesced.
 475   @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED Interrupt source was handled and quiesced.
 476
 477 **/
 478 EFI_STATUS
 479 EFIAPI
 480 SmiManage (
 481   IN     CONST EFI_GUID           *HandlerType,
 482   IN     CONST VOID               *Context         OPTIONAL,
 483   IN OUT VOID                     *CommBuffer      OPTIONAL,
 484   IN OUT UINTN                    *CommBufferSize  OPTIONAL
 485   );
 486
 487 /**
 488   Registers a handler to execute within SMM.
 489
 490   @param  Handler        Handler service funtion pointer.
 491   @param  HandlerType    Points to the handler type or NULL for root SMI handlers.
 492   @param  DispatchHandle On return, contains a unique handle which can be used to later unregister the handler function.
 493
 494   @retval EFI_SUCCESS           Handler register success.
 495   @retval EFI_INVALID_PARAMETER Handler or DispatchHandle is NULL.
 496
 497 **/
 498 EFI_STATUS
 499 EFIAPI
 500 SmiHandlerRegister (
 501   IN   EFI_SMM_HANDLER_ENTRY_POINT2   Handler,
 502   IN   CONST EFI_GUID                 *HandlerType  OPTIONAL,
 503   OUT  EFI_HANDLE                     *DispatchHandle
 504   );
 505
 506 /**
 507   Unregister a handler in SMM.
 508
 509   @param  DispatchHandle  The handle that was specified when the handler was registered.
 510
 511   @retval EFI_SUCCESS           Handler function was successfully unregistered.
 512   @retval EFI_INVALID_PARAMETER DispatchHandle does not refer to a valid handle.
 513
 514 **/
 515 EFI_STATUS
 516 EFIAPI
 517 SmiHandlerUnRegister (
 518   IN  EFI_HANDLE                      DispatchHandle
 519   );
 520
 521 /**
 522   This function is the main entry point for an SMM handler dispatch
 523   or communicate-based callback.
 524
 525   @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().
 526   @param  Context         Points to an optional handler context which was specified when the handler was registered.
 527   @param  CommBuffer      A pointer to a collection of data in memory that will
 528                           be conveyed from a non-SMM environment into an SMM environment.
 529   @param  CommBufferSize  The size of the CommBuffer.
 530
 531   @return Status Code
 532
 533 **/
 534 EFI_STATUS
 535 EFIAPI
 536 SmmDriverDispatchHandler (
 537   IN     EFI_HANDLE               DispatchHandle,
 538   IN     CONST VOID               *Context,        OPTIONAL
 539   IN OUT VOID                     *CommBuffer,     OPTIONAL
 540   IN OUT UINTN                    *CommBufferSize  OPTIONAL
 541   );
 542
 543 /**
 544   This function is the main entry point for an SMM handler dispatch
 545   or communicate-based callback.
 546
 547   @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().
 548   @param  Context         Points to an optional handler context which was specified when the handler was registered.
 549   @param  CommBuffer      A pointer to a collection of data in memory that will
 550                           be conveyed from a non-SMM environment into an SMM environment.
 551   @param  CommBufferSize  The size of the CommBuffer.
 552
 553   @return Status Code
 554
 555 **/
 556 EFI_STATUS
 557 EFIAPI
 558 SmmLegacyBootHandler (
 559   IN     EFI_HANDLE               DispatchHandle,
 560   IN     CONST VOID               *Context,        OPTIONAL
 561   IN OUT VOID                     *CommBuffer,     OPTIONAL
 562   IN OUT UINTN                    *CommBufferSize  OPTIONAL
 563   );
 564
 565 /**
 566   This function is the main entry point for an SMM handler dispatch
 567   or communicate-based callback.
 568
 569   @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().
 570   @param  Context         Points to an optional handler context which was specified when the handler was registered.
 571   @param  CommBuffer      A pointer to a collection of data in memory that will
 572                           be conveyed from a non-SMM environment into an SMM environment.
 573   @param  CommBufferSize  The size of the CommBuffer.
 574
 575   @return Status Code
 576
 577 **/
 578 EFI_STATUS
 579 EFIAPI
 580 SmmReadyToLockHandler (
 581   IN     EFI_HANDLE               DispatchHandle,
 582   IN     CONST VOID               *Context,        OPTIONAL
 583   IN OUT VOID                     *CommBuffer,     OPTIONAL
 584   IN OUT UINTN                    *CommBufferSize  OPTIONAL
 585   );
 586
 587 /**
 588   Place holder function until all the SMM System Table Service are available.
 589
 590   @param  Arg1                   Undefined
 591   @param  Arg2                   Undefined
 592   @param  Arg3                   Undefined
 593   @param  Arg4                   Undefined
 594   @param  Arg5                   Undefined
 595
 596   @return EFI_NOT_AVAILABLE_YET
 597
 598 **/
 599 EFI_STATUS
 600 EFIAPI
 601 SmmEfiNotAvailableYetArg5 (
 602   UINTN Arg1,
 603   UINTN Arg2,
 604   UINTN Arg3,
 605   UINTN Arg4,
 606   UINTN Arg5
 607   );
 608
 609 //
 610 //Functions used during debug buils
 611 //
 612
 613 /**
 614   Traverse the discovered list for any drivers that were discovered but not loaded
 615   because the dependency experessions evaluated to false.
 616
 617 **/
 618 VOID
 619 SmmDisplayDiscoveredNotDispatched (
 620   VOID
 621   );
 622
 623 /**
 624   Add free SMRAM region for use by memory service.
 625
 626   @param  MemBase                Base address of memory region.
 627   @param  MemLength              Length of the memory region.
 628   @param  Type                   Memory type.
 629   @param  Attributes             Memory region state.
 630
 631 **/
 632 VOID
 633 SmmAddMemoryRegion (
 634   IN      EFI_PHYSICAL_ADDRESS      MemBase,
 635   IN      UINT64                    MemLength,
 636   IN      EFI_MEMORY_TYPE           Type,
 637   IN      UINT64                    Attributes
 638   );
 639
 640 /**
 641   Finds the protocol entry for the requested protocol.
 642
 643   @param  Protocol               The ID of the protocol
 644   @param  Create                 Create a new entry if not found
 645
 646   @return Protocol entry
 647
 648 **/
 649 PROTOCOL_ENTRY  *
 650 SmmFindProtocolEntry (
 651   IN EFI_GUID   *Protocol,
 652   IN BOOLEAN    Create
 653   );
 654
 655 /**
 656   Signal event for every protocol in protocol entry.
 657
 658   @param  Prot                   Protocol interface
 659
 660 **/
 661 VOID
 662 SmmNotifyProtocol (
 663   IN PROTOCOL_INTERFACE   *Prot
 664   );
 665
 666 /**
 667   Finds the protocol instance for the requested handle and protocol.
 668   Note: This function doesn't do parameters checking, it's caller's responsibility
 669   to pass in valid parameters.
 670
 671   @param  Handle                 The handle to search the protocol on
 672   @param  Protocol               GUID of the protocol
 673   @param  Interface              The interface for the protocol being searched
 674
 675   @return Protocol instance (NULL: Not found)
 676
 677 **/
 678 PROTOCOL_INTERFACE *
 679 SmmFindProtocolInterface (
 680   IN IHANDLE        *Handle,
 681   IN EFI_GUID       *Protocol,
 682   IN VOID           *Interface
 683   );
 684
 685 /**
 686   Removes Protocol from the protocol list (but not the handle list).
 687
 688   @param  Handle                 The handle to remove protocol on.
 689   @param  Protocol               GUID of the protocol to be moved
 690   @param  Interface              The interface of the protocol
 691
 692   @return Protocol Entry
 693
 694 **/
 695 PROTOCOL_INTERFACE *
 696 SmmRemoveInterfaceFromProtocol (
 697   IN IHANDLE        *Handle,
 698   IN EFI_GUID       *Protocol,
 699   IN VOID           *Interface
 700   );
 701
 702 /**
 703   This is the POSTFIX version of the dependency evaluator.  This code does
 704   not need to handle Before or After, as it is not valid to call this
 705   routine in this case. POSTFIX means all the math is done on top of the stack.
 706
 707   @param  DriverEntry           DriverEntry element to update.
 708
 709   @retval TRUE                  If driver is ready to run.
 710   @retval FALSE                 If driver is not ready to run or some fatal error
 711                                 was found.
 712
 713 **/
 714 BOOLEAN
 715 SmmIsSchedulable (
 716   IN  EFI_SMM_DRIVER_ENTRY   *DriverEntry
 717   );
 718
 719 #endif