1 /*++ 2 3 Copyright (c) 1999 - 2006, 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 Module Name: 14 15 SmmBase.h 16 17 Abstract: 18 19 This file defines SMM Base abstraction protocol defined by the SMM Architecture 20 Specification. This is the base level of compatiblity for SMM drivers. 21 22 --*/ 23 24 #ifndef _SMM_BASE_H_ 25 #define _SMM_BASE_H_ 26 27 #include EFI_PROTOCOL_DEFINITION (DevicePath) 28 29 #define EFI_SMM_BASE_PROTOCOL_GUID \ 30 { \ 31 0x1390954D, 0xda95, 0x4227, {0x93, 0x28, 0x72, 0x82, 0xc2, 0x17, 0xda, 0xa8} \ 32 } 33 34 #define EFI_SMM_CPU_IO_GUID \ 35 { \ 36 0x5f439a0b, 0x45d8, 0x4682, {0xa4, 0xf4, 0xf0, 0x57, 0x6b, 0x51, 0x34, 0x41} \ 37 } 38 39 #define SMM_COMMUNICATE_HEADER_GUID \ 40 { \ 41 0xF328E36C, 0x23B6, 0x4a95, {0x85, 0x4B, 0x32, 0xE1, 0x95, 0x34, 0xCD, 0x75} \ 42 } 43 44 // 45 // SMM Base specification constant and types 46 // 47 #define SMM_SMST_SIGNATURE EFI_SIGNATURE_32 ('S', 'M', 'S', 'T') 48 #define EFI_SMM_SYSTEM_TABLE_REVISION (0 << 16) | (0x09) 49 50 EFI_FORWARD_DECLARATION (EFI_SMM_BASE_PROTOCOL); 51 EFI_FORWARD_DECLARATION (EFI_SMM_CPU_IO_INTERFACE); 52 EFI_FORWARD_DECLARATION (EFI_SMM_CPU_SAVE_STATE); 53 EFI_FORWARD_DECLARATION (EFI_SMM_OPTIONAL_FP_SAVE_STATE); 54 EFI_FORWARD_DECLARATION (EFI_SMM_SYSTEM_TABLE); 55 56 // 57 // ******************************************************* 58 // EFI_SMM_IO_WIDTH 59 // ******************************************************* 60 // 61 typedef enum { 62 SMM_IO_UINT8 = 0, 63 SMM_IO_UINT16 = 1, 64 SMM_IO_UINT32 = 2, 65 SMM_IO_UINT64 = 3 66 } EFI_SMM_IO_WIDTH; 67 68 // 69 // ******************************************************* 70 // EFI_SMM_IO_ACCESS 71 // ******************************************************* 72 // 73 typedef 74 EFI_STATUS 75 (EFIAPI *EFI_SMM_CPU_IO) ( 76 IN EFI_SMM_CPU_IO_INTERFACE * This, 77 IN EFI_SMM_IO_WIDTH Width, 78 IN UINT64 Address, 79 IN UINTN Count, 80 IN OUT VOID *Buffer 81 ); 82 83 typedef struct { 84 EFI_SMM_CPU_IO Read; 85 EFI_SMM_CPU_IO Write; 86 } EFI_SMM_IO_ACCESS; 87 88 struct _EFI_SMM_CPU_IO_INTERFACE { 89 EFI_SMM_IO_ACCESS Mem; 90 EFI_SMM_IO_ACCESS Io; 91 }; 92 93 typedef 94 EFI_STATUS 95 (EFIAPI *EFI_SMMCORE_ALLOCATE_POOL) ( 96 IN EFI_MEMORY_TYPE PoolType, 97 IN UINTN Size, 98 OUT VOID **Buffer 99 ); 100 101 typedef 102 EFI_STATUS 103 (EFIAPI *EFI_SMMCORE_FREE_POOL) ( 104 IN VOID *Buffer 105 ); 106 107 typedef 108 EFI_STATUS 109 (EFIAPI *EFI_SMMCORE_ALLOCATE_PAGES) ( 110 IN EFI_ALLOCATE_TYPE Type, 111 IN EFI_MEMORY_TYPE MemoryType, 112 IN UINTN NumberOfPages, 113 OUT EFI_PHYSICAL_ADDRESS * Memory 114 ); 115 116 typedef 117 EFI_STATUS 118 (EFIAPI *EFI_SMMCORE_FREE_PAGES) ( 119 IN EFI_PHYSICAL_ADDRESS Memory, 120 IN UINTN NumberOfPages 121 ); 122 123 typedef 124 VOID 125 (EFIAPI *EFI_AP_PROCEDURE) ( 126 IN VOID *Buffer 127 ); 128 129 typedef 130 EFI_STATUS 131 (EFIAPI *EFI_SMM_STARTUP_THIS_AP) ( 132 IN EFI_AP_PROCEDURE Procedure, 133 IN UINTN CpuNumber, 134 IN OUT VOID *ProcArguments OPTIONAL 135 ); 136 137 struct _EFI_SMM_CPU_SAVE_STATE { 138 UINT8 Reserved1[248]; 139 UINT32 SMBASE; 140 UINT32 SMMRevId; 141 UINT16 IORestart; 142 UINT16 AutoHALTRestart; 143 UINT8 Reserved2[164]; 144 UINT32 ES; 145 UINT32 CS; 146 UINT32 SS; 147 UINT32 DS; 148 UINT32 FS; 149 UINT32 GS; 150 UINT32 LDTBase; 151 UINT32 TR; 152 UINT32 DR7; 153 UINT32 DR6; 154 UINT32 EAX; 155 UINT32 ECX; 156 UINT32 EDX; 157 UINT32 EBX; 158 UINT32 ESP; 159 UINT32 EBP; 160 UINT32 ESI; 161 UINT32 EDI; 162 UINT32 EIP; 163 UINT32 EFLAGS; 164 UINT32 CR3; 165 UINT32 CR0; 166 }; 167 168 typedef struct { 169 UINT8 Reserved19[760]; // FC00 170 UINT32 SMBASE; // FEF8 171 UINT32 REVID; // FEFC 172 UINT16 HALT_RESTART; // FF00 173 UINT16 IO_RESTART; // FF02 174 UINT32 Reserved17[22]; // FF58, 54, 50, 4c, 48, 44, 40, 3c, 38, 34, 30, 2c, 28, 24, 20, 1c, 18, 14, 10, 0c, 08, 04 175 UINT32 EAX; // FF5C 176 UINT32 Reserved16; // FF60 177 UINT32 ECX; // FF64 178 UINT32 Reserved15; // FF68 179 UINT32 EDX; // FF6C 180 UINT32 Reserved14; // FF70 181 UINT32 EBX; // FF74 182 UINT32 Reserved13; // FF78 183 UINT32 ESP; // FF7C 184 UINT32 Reserved12; // FF80 185 UINT32 EBP; // FF84 186 UINT32 Reserved11; // FF88 187 UINT32 ESI; // FF8C 188 UINT32 Reserved9; // FF90 189 UINT32 EDI; // FF94 190 UINT32 Reserved8; // FF98 191 UINT32 IO_MEM_ADDR; // FF9C 192 UINT32 Reserved7; // FFA0 193 UINT32 IO_MISC; // FFA4 194 UINT32 ES_SEL; // FFA8 195 UINT32 CS_SEL; // FFAC 196 UINT32 SS_SEL; // FFB0 197 UINT32 DS_SEL; // FFB4 198 UINT32 FS_SEL; // FFB8 199 UINT32 GS_SEL; // FFBC 200 UINT32 LDTR_SEL; // FFC0 201 UINT32 TR_SEL; // FFC4 202 UINT32 DR7; // FFC8 203 UINT32 Reserved6; // FFCC 204 UINT32 DR6; // FFD0 205 UINT32 Reserved5; // FFD4 206 UINT32 EIP; // FFD8 207 UINT32 Reserved4; // FFDC 208 UINT32 EFER; // FFE0 209 UINT32 Reserved3; // FFE4 210 UINT32 EFLAGS; // FFE8 211 UINT32 Reserved2; // FFEC 212 UINT32 CR3; // FFF0 213 UINT32 Reserved1; // FFF4 214 UINT32 CR0; // FFF8 215 UINT32 Reserved0; // FFFC 216 } EFI_SMM_CPU_CT_SAVE_STATE; 217 218 typedef struct { 219 UINT8 Reserved26[464]; // FC00 - FDCF 220 UINT32 GdtrUpperBase; // FDD0 221 UINT32 LdtrUpperBase; // FDD4 222 UINT32 IdtrUpperBase; // FDD8 223 UINT32 Reserved25; // FDDC - FDDF 224 UINT64 IoRdi; // FDE0 225 UINT64 IoRip; // FDE8 226 UINT64 IoRcx; // FDF0 227 UINT64 IoRsi; // FDF8 228 UINT8 Reserved24[64]; // FE00 - FE3F 229 UINT64 Cr4; // FE40 230 UINT8 Reserved23[68]; // FE48 - FE8B 231 UINT32 GdtrBase; // FE8C 232 UINT32 Reserved22; // FE90 233 UINT32 IdtrBase; // FE94 234 UINT32 Reserved21; // FE98 235 UINT32 LdtrBase; // FE9C 236 UINT32 Reserved20; // FEA0 237 UINT8 Reserved19[84]; // FEA4 - FEF7 238 UINT32 Smbase; // FEF8 239 UINT32 RevId; // FEFC 240 UINT16 IoRestart; // FF00 241 UINT16 HaltRestart; // FF02 242 UINT8 Reserved18[24]; // FF04 - FF1B 243 UINT32 R15; // FF1C 244 UINT32 Reserved17; // FE20 245 UINT32 R14; // FF24 246 UINT32 Reserved16; // FE28 247 UINT32 R13; // FF2C 248 UINT32 Reserved15; // FE30 249 UINT32 R12; // FF34 250 UINT32 Reserved14; // FE38 251 UINT32 R11; // FF3C 252 UINT32 Reserved13; // FE40 253 UINT32 R10; // FF44 254 UINT32 Reserved12; // FE48 255 UINT32 R9; // FF4C 256 UINT32 Reserved11; // FE50 257 UINT32 R8; // FF54 258 UINT32 Reserved10; // FE58 259 UINT32 Rax; // FF5C 260 UINT32 Reserved9; // FE60 261 UINT32 Rcx; // FF64 262 UINT32 Reserved8; // FE68 263 UINT32 Rdx; // FF6C 264 UINT32 Reserved7; // FE70 265 UINT32 Rbx; // FF74 266 UINT32 Reserved6; // FE78 267 UINT32 Rsp; // FF7C 268 UINT32 Reserved5; // FE80 269 UINT32 Rbp; // FF84 270 UINT32 Reserved4; // FE88 271 UINT32 Rsi; // FF8C 272 UINT32 Reserved3; // FE90 273 UINT32 Rdi; // FF94 274 UINT32 Reserved2; // FE98 275 UINT32 IoMemAddr; // FF9C 276 UINT32 Reserved1; // FEA0 277 UINT32 IoMiscInfo; // FFA4 278 UINT32 EsSel; // FFA8 279 UINT32 CsSel; // FFAC 280 UINT32 SsSel; // FFB0 281 UINT32 DsSel; // FFB4 282 UINT32 FsSel; // FFB8 283 UINT32 GsSel; // FFBC 284 UINT32 LdtrSel; // FFC0 285 UINT32 TrSel; // FFC4 286 UINT64 Dr7; // FFC8 287 UINT64 Dr6; // FFD0 288 UINT32 Rip; // FFD8 289 UINT32 Reserved0; // FFDC 290 UINT64 Efr; // FFE0 291 UINT64 RFlags; // FFE8 292 UINT64 Cr3; // FFF0 293 UINT64 Cr0; // FFF8 294 } EFI_SMM_CPU_MEROM_SAVE_STATE; 295 296 297 typedef struct { 298 UINT8 Reserved14[0x228]; // FC00-FE28 299 UINT32 IO_EIP; // FE28 300 UINT8 Reserved13[0x14]; // FE2C-FE40 301 UINT32 CR4; // FE40 302 UINT8 Reserved12[0x48]; // FE44-FE8C 303 UINT32 GDT_BASE; // FE8C 304 UINT8 Reserved11[0xC]; // FE90-FE9C 305 UINT32 LDT_BASE; // FE9C 306 UINT8 Reserved10[0x58]; // FEA0-FEF8 307 UINT32 SMBASE; 308 UINT32 REVID; 309 UINT16 IO_RESTART; 310 UINT16 HALT_RESTART; 311 UINT8 Reserved9[0xA4]; 312 313 UINT16 ES; 314 UINT16 Reserved8; 315 UINT16 CS; 316 UINT16 Reserved7; 317 UINT16 SS; 318 UINT16 Reserved6; 319 UINT16 DS; 320 UINT16 Reserved5; 321 UINT16 FS; 322 UINT16 Reserved4; 323 UINT16 GS; 324 UINT16 Reserved3; 325 UINT32 Reserved2; 326 UINT16 TR; 327 UINT16 Reserved1; 328 UINT32 DR7; 329 UINT32 DR6; 330 UINT32 EAX; 331 UINT32 ECX; 332 UINT32 EDX; 333 UINT32 EBX; 334 UINT32 ESP; 335 UINT32 EBP; 336 UINT32 ESI; 337 UINT32 EDI; 338 UINT32 EIP; 339 UINT32 EFLAGS; 340 UINT32 CR3; 341 UINT32 CR0; 342 } EFI_SMM_CPU_CT_NOT_ENABLED_SAVE_STATE; 343 344 struct _EFI_SMM_OPTIONAL_FP_SAVE_STATE { 345 UINT16 Fcw; 346 UINT16 Fsw; 347 UINT16 Ftw; 348 UINT16 Opcode; 349 UINT32 Eip; 350 UINT16 Cs; 351 UINT16 Rsvd1; 352 UINT32 DataOffset; 353 UINT16 Ds; 354 UINT8 Rsvd2[10]; 355 UINT8 St0Mm0[10], Rsvd3[6]; 356 UINT8 St0Mm1[10], Rsvd4[6]; 357 UINT8 St0Mm2[10], Rsvd5[6]; 358 UINT8 St0Mm3[10], Rsvd6[6]; 359 UINT8 St0Mm4[10], Rsvd7[6]; 360 UINT8 St0Mm5[10], Rsvd8[6]; 361 UINT8 St0Mm6[10], Rsvd9[6]; 362 UINT8 St0Mm7[10], Rsvd10[6]; 363 UINT8 Rsvd11[22 * 16]; 364 }; 365 366 typedef struct _EFI_SMM_OPTIONAL_FP_SAVE_STATE32 { 367 UINT16 Fcw; 368 UINT16 Fsw; 369 UINT16 Ftw; 370 UINT16 Opcode; 371 UINT32 Eip; 372 UINT16 Cs; 373 UINT16 Rsvd1; 374 UINT32 DataOffset; 375 UINT16 Ds; 376 UINT8 Reserved2[10]; 377 UINT8 St0Mm0[10], Rsvd3[6]; 378 UINT8 St1Mm1[10], Rsvd4[6]; 379 UINT8 St2Mm2[10], Rsvd5[6]; 380 UINT8 St3Mm3[10], Rsvd6[6]; 381 UINT8 St4Mm4[10], Rsvd7[6]; 382 UINT8 St5Mm5[10], Rsvd8[6]; 383 UINT8 St6Mm6[10], Rsvd9[6]; 384 UINT8 St7Mm7[10], Rsvd10[6]; 385 UINT8 Xmm0[16]; 386 UINT8 Xmm1[16]; 387 UINT8 Xmm2[16]; 388 UINT8 Xmm3[16]; 389 UINT8 Xmm4[16]; 390 UINT8 Xmm5[16]; 391 UINT8 Xmm6[16]; 392 UINT8 Xmm7[16]; 393 UINT8 Rsvd11[14 * 16]; 394 } EFI_SMM_OPTIONAL_FP_SAVE_STATE32; 395 396 typedef struct _EFI_SMM_OPTIONAL_FP_SAVE_STATE64 { 397 UINT16 Fcw; 398 UINT16 Fsw; 399 UINT16 Ftw; 400 UINT16 Opcode; 401 UINT64 Rip; 402 UINT64 DataOffset; 403 UINT8 Rsvd1[8]; 404 UINT8 St0Mm0[10], Rsvd2[6]; 405 UINT8 St1Mm1[10], Rsvd3[6]; 406 UINT8 St2Mm2[10], Rsvd4[6]; 407 UINT8 St3Mm3[10], Rsvd5[6]; 408 UINT8 St4Mm4[10], Rsvd6[6]; 409 UINT8 St5Mm5[10], Rsvd7[6]; 410 UINT8 St6Mm6[10], Rsvd8[6]; 411 UINT8 St7Mm7[10], Rsvd9[6]; 412 UINT8 Xmm0[16]; 413 UINT8 Xmm1[16]; 414 UINT8 Xmm2[16]; 415 UINT8 Xmm3[16]; 416 UINT8 Xmm4[16]; 417 UINT8 Xmm5[16]; 418 UINT8 Xmm6[16]; 419 UINT8 Xmm7[16]; 420 UINT8 Xmm8[16]; 421 UINT8 Xmm9[16]; 422 UINT8 Xmm10[16]; 423 UINT8 Xmm11[16]; 424 UINT8 Xmm12[16]; 425 UINT8 Xmm13[16]; 426 UINT8 Xmm14[16]; 427 UINT8 Xmm15[16]; 428 UINT8 Rsvd10[6 * 16]; 429 } EFI_SMM_OPTIONAL_FP_SAVE_STATE64; 430 431 struct _EFI_SMM_SYSTEM_TABLE; 432 433 typedef 434 EFI_STATUS 435 (EFIAPI *EFI_SMM_INSTALL_CONFIGURATION_TABLE) ( 436 IN EFI_SMM_SYSTEM_TABLE * SystemTable, 437 IN EFI_GUID * Guid, 438 IN VOID *Table, 439 IN UINTN TableSize 440 ) 441 /*++ 442 443 Routine Description: 444 The SmmInstallConfigurationTable() function is used to maintain the list 445 of configuration tables that are stored in the System Management System 446 Table. The list is stored as an array of (GUID, Pointer) pairs. The list 447 must be allocated from pool memory with PoolType set to EfiRuntimeServicesData. 448 449 Arguments: 450 SystemTable - A pointer to the SMM System Table. 451 Guid - A pointer to the GUID for the entry to add, update, or remove. 452 Table - A pointer to the buffer of the table to add. 453 TableSize - The size of the table to install. 454 455 Returns: 456 EFI_SUCCESS - The (Guid, Table) pair was added, updated, or removed. 457 EFI_INVALID_PARAMETER - Guid is not valid. 458 EFI_NOT_FOUND - An attempt was made to delete a non-existent entry. 459 EFI_OUT_OF_RESOURCES - There is not enough memory available to complete the operation. 460 461 --*/ 462 ; 463 464 // 465 // System Management System Table (SMST) 466 // 467 struct _EFI_SMM_SYSTEM_TABLE { 468 EFI_TABLE_HEADER Hdr; 469 470 CHAR16 *SmmFirmwareVendor; 471 UINT32 SmmFirmwareRevision; 472 473 EFI_SMM_INSTALL_CONFIGURATION_TABLE SmmInstallConfigurationTable; 474 475 // 476 // I/O Services 477 // 478 EFI_GUID EfiSmmCpuIoGuid; 479 EFI_SMM_CPU_IO_INTERFACE SmmIo; 480 481 // 482 // Runtime memory service 483 // 484 EFI_SMMCORE_ALLOCATE_POOL SmmAllocatePool; 485 EFI_SMMCORE_FREE_POOL SmmFreePool; 486 EFI_SMMCORE_ALLOCATE_PAGES SmmAllocatePages; 487 EFI_SMMCORE_FREE_PAGES SmmFreePages; 488 489 // 490 // MP service 491 // 492 EFI_SMM_STARTUP_THIS_AP SmmStartupThisAp; 493 494 // 495 // CPU information records 496 // 497 UINTN CurrentlyExecutingCpu; 498 UINTN NumberOfCpus; 499 EFI_SMM_CPU_SAVE_STATE *CpuSaveState; 500 EFI_SMM_OPTIONAL_FP_SAVE_STATE *CpuOptionalFloatingPointState; 501 502 // 503 // Extensibility table 504 // 505 UINTN NumberOfTableEntries; 506 EFI_CONFIGURATION_TABLE *SmmConfigurationTable; 507 508 }; 509 510 // 511 // SMM Handler Definition 512 // 513 #define EFI_HANDLER_SUCCESS 0x0000 514 #define EFI_HANDLER_CRITICAL_EXIT 0x0001 515 #define EFI_HANDLER_SOURCE_QUIESCED 0x0002 516 #define EFI_HANDLER_SOURCE_PENDING 0x0003 517 518 // 519 // Structure of Communicate Buffer 520 // 521 typedef struct { 522 EFI_GUID HeaderGuid; 523 UINTN MessageLength; 524 UINT8 Data[1]; 525 } EFI_SMM_COMMUNICATE_HEADER; 526 527 typedef 528 EFI_STATUS 529 (EFIAPI *EFI_SMM_HANDLER_ENTRY_POINT) ( 530 IN EFI_HANDLE SmmImageHandle, 531 IN OUT VOID *CommunicationBuffer OPTIONAL, 532 IN OUT UINTN *SourceSize OPTIONAL 533 ); 534 535 typedef 536 EFI_STATUS 537 (EFIAPI *EFI_SMM_CALLBACK_ENTRY_POINT) ( 538 IN EFI_HANDLE SmmImageHandle, 539 IN OUT VOID *CommunicationBuffer OPTIONAL, 540 IN OUT UINTN *SourceSize OPTIONAL 541 ); 542 543 typedef struct { 544 EFI_HANDLE SmmHandler; 545 EFI_DEVICE_PATH_PROTOCOL *HandlerDevicePath; 546 } EFI_HANDLER_DESCRIPTOR; 547 548 // 549 // SMM Base Protocol Definition 550 // 551 typedef 552 EFI_STATUS 553 (EFIAPI *EFI_SMM_REGISTER_HANDLER) ( 554 IN EFI_SMM_BASE_PROTOCOL * This, 555 IN EFI_DEVICE_PATH_PROTOCOL * FilePath, 556 IN VOID *SourceBuffer OPTIONAL, 557 IN UINTN SourceSize, 558 OUT EFI_HANDLE * ImageHandle, 559 IN BOOLEAN LegacyIA32Binary OPTIONAL 560 ) 561 /*++ 562 563 Routine Description: 564 Register a given driver into SMRAM. This is the equivalent of performing 565 the LoadImage/StartImage into System Management Mode. 566 567 Arguments: 568 This - Protocol instance pointer. 569 SourceBuffer - Optional source buffer in case of the image file 570 being in memory. 571 SourceSize - Size of the source image file, if in memory. 572 ImageHandle - Pointer to the handle that reflects the driver 573 loaded into SMM. 574 LegacyIA32Binary - The binary image to load is legacy 16 bit code. 575 576 Returns: 577 EFI_SUCCESS - The operation was successful. 578 EFI_OUT_OF_RESOURCES - There were no additional SMRAM resources to load the handler 579 EFI_UNSUPPORTED - This platform does not support 16-bit handlers. 580 EFI_UNSUPPORTED - In runtime. 581 EFI_INVALID_PARAMETER - The handlers was not the correct image type 582 583 --*/ 584 ; 585 586 typedef 587 EFI_STATUS 588 (EFIAPI *EFI_SMM_UNREGISTER_HANDLER) ( 589 IN EFI_SMM_BASE_PROTOCOL * This, 590 IN EFI_HANDLE ImageHandle 591 ) 592 /*++ 593 594 Routine Description: 595 Remove a given driver SMRAM. This is the equivalent of performing 596 the UnloadImage System Management Mode. 597 598 Arguments: 599 This - Protocol instance pointer. 600 ImageHandle - Pointer to the handle that reflects the driver 601 loaded into SMM. 602 603 Returns: 604 EFI_SUCCESS - The operation was successful 605 EFI_INVALID_PARAMETER - The handler did not exist 606 EFI_UNSUPPORTED - In runtime. 607 608 --*/ 609 ; 610 611 typedef 612 EFI_STATUS 613 (EFIAPI *EFI_SMM_COMMUNICATE) ( 614 IN EFI_SMM_BASE_PROTOCOL * This, 615 IN EFI_HANDLE ImageHandle, 616 IN OUT VOID *CommunicationBuffer, 617 IN OUT UINTN *SourceSize 618 ) 619 /*++ 620 621 Routine Description: 622 The SMM Inter-module Communicate Service Communicate() function 623 provides a services to send/received messages from a registered 624 EFI service. The BASE protocol driver is responsible for doing 625 any of the copies such that the data lives in boot-service accessible RAM. 626 627 Arguments: 628 This - Protocol instance pointer. 629 ImageHandle - Pointer to the handle that reflects the driver 630 loaded into SMM. 631 CommunicationBuffer - Pointer to the buffer to convey into SMRAM. 632 SourceSize - Size of the contents of buffer.. 633 634 Returns: 635 EFI_SUCCESS - The message was successfully posted 636 EFI_INVALID_PARAMETER - The buffer was NULL 637 638 --*/ 639 ; 640 641 typedef 642 EFI_STATUS 643 (EFIAPI *EFI_SMM_CALLBACK_SERVICE) ( 644 IN EFI_SMM_BASE_PROTOCOL * This, 645 IN EFI_HANDLE SmmImageHandle, 646 IN EFI_SMM_CALLBACK_ENTRY_POINT CallbackAddress, 647 IN BOOLEAN MakeLast OPTIONAL, 648 IN BOOLEAN FloatingPointSave OPTIONAL 649 ) 650 /*++ 651 652 Routine Description: 653 Register a callback to execute within SMM. 654 This allows receipt of messages created with the Boot Service COMMUNICATE. 655 656 Arguments: 657 This - Protocol instance pointer. 658 CallbackAddress - Address of the callback service 659 MakeFirst - If present, will stipulate that the handler is posted 660 to be the first module executed in the dispatch table. 661 MakeLast - If present, will stipulate that the handler is posted 662 to be last executed in the dispatch table. 663 FloatingPointSave - This is an optional parameter which informs the 664 EFI_SMM_ACCESS_PROTOCOL Driver core if it needs to save 665 the floating point register state. If any of the handlers 666 require this, then the state will be saved for all of the handlers. 667 668 Returns: 669 EFI_SUCCESS - The operation was successful 670 EFI_OUT_OF_RESOURCES - Not enough space in the dispatch queue 671 EFI_UNSUPPORTED - In runtime. 672 EFI_UNSUPPORTED - Not in SMM. 673 674 --*/ 675 ; 676 677 typedef 678 EFI_STATUS 679 (EFIAPI *EFI_SMM_ALLOCATE_POOL) ( 680 IN EFI_SMM_BASE_PROTOCOL * This, 681 IN EFI_MEMORY_TYPE PoolType, 682 IN UINTN Size, 683 OUT VOID **Buffer 684 ) 685 /*++ 686 687 Routine Description: 688 The SmmAllocatePool() function allocates a memory region of Size bytes from memory of 689 type PoolType and returns the address of the allocated memory in the location referenced 690 by Buffer. This function allocates pages from EFI SMRAM Memory as needed to grow the 691 requested pool type. All allocations are eight-byte aligned. 692 693 Arguments: 694 This - Protocol instance pointer. 695 PoolType - The type of pool to allocate. 696 The only supported type is EfiRuntimeServicesData; 697 the interface will internally map this runtime request to SMRAM. 698 Size - The number of bytes to allocate from the pool. 699 Buffer - A pointer to a pointer to the allocated buffer if the call 700 succeeds; undefined otherwise. 701 702 Returns: 703 EFI_SUCCESS - The requested number of bytes was allocated. 704 EFI_OUT_OF_RESOURCES - The pool requested could not be allocated. 705 EFI_INVALID_PARAMETER - PoolType was invalid. 706 EFI_UNSUPPORTED - In runtime. 707 708 --*/ 709 ; 710 711 typedef 712 EFI_STATUS 713 (EFIAPI *EFI_SMM_FREE_POOL) ( 714 IN EFI_SMM_BASE_PROTOCOL * This, 715 IN VOID *Buffer 716 ) 717 /*++ 718 719 Routine Description: 720 The SmmFreePool() function returns the memory specified by Buffer to the system. 721 On return, the memory's type is EFI SMRAM Memory. The Buffer that is freed must 722 have been allocated by SmmAllocatePool(). 723 724 Arguments: 725 This - Protocol instance pointer. 726 Buffer - Pointer to the buffer allocation. 727 728 Returns: 729 EFI_SUCCESS - The memory was returned to the system. 730 EFI_INVALID_PARAMETER - Buffer was invalid. 731 EFI_UNSUPPORTED - In runtime. 732 733 --*/ 734 ; 735 736 typedef 737 EFI_STATUS 738 (EFIAPI *EFI_SMM_INSIDE_OUT) ( 739 IN EFI_SMM_BASE_PROTOCOL * This, 740 OUT BOOLEAN *InSmm 741 ) 742 /*++ 743 744 Routine Description: 745 This routine tells caller if execution context is SMM or not. 746 747 Arguments: 748 This - Protocol instance pointer. 749 750 Returns: 751 EFI_SUCCESS - The operation was successful 752 753 --*/ 754 ; 755 756 typedef 757 EFI_STATUS 758 (EFIAPI *EFI_SMM_GET_SMST_LOCATION) ( 759 IN EFI_SMM_BASE_PROTOCOL * This, 760 IN OUT EFI_SMM_SYSTEM_TABLE **Smst 761 ) 762 /*++ 763 764 Routine Description: 765 The GetSmstLocation() function returns the locatin of the System Management 766 Service Table. The use of the API is such that a driver can discover the 767 location of the SMST in its entry point and then cache it in some driver 768 global variable so that the SMST can be invoked in subsequent callbacks. 769 770 Arguments: 771 This - Protocol instance pointer. 772 Smst - Pointer to the SMST. 773 774 Returns: 775 EFI_SUCCESS - The operation was successful 776 EFI_INVALID_PARAMETER - Smst was invalid. 777 EFI_UNSUPPORTED - Not in SMM. 778 779 --*/ 780 ; 781 782 struct _EFI_SMM_BASE_PROTOCOL { 783 EFI_SMM_REGISTER_HANDLER Register; 784 EFI_SMM_UNREGISTER_HANDLER UnRegister; 785 EFI_SMM_COMMUNICATE Communicate; 786 EFI_SMM_CALLBACK_SERVICE RegisterCallback; 787 EFI_SMM_INSIDE_OUT InSmm; 788 EFI_SMM_ALLOCATE_POOL SmmAllocatePool; 789 EFI_SMM_FREE_POOL SmmFreePool; 790 EFI_SMM_GET_SMST_LOCATION GetSmstLocation; 791 }; 792 793 extern EFI_GUID gEfiSmmBaseProtocolGuid; 794 extern EFI_GUID gEfiSmmCpuIoGuid; 795 extern EFI_GUID gEfiSmmCommunicateHeaderGuid; 796 797 #endif 798