Vlv2TbltDevicePkg/PlatformSmm/SmmScriptSave.c

   1 /** @file
   2
   3   Copyright (c) 2004  - 2014, Intel Corporation. All rights reserved.<BR>
   4
   5   SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7
   8
   9
  10 Module Name:
  11
  12
  13     SmmScriptSave.c
  14
  15 Abstract:
  16
  17     ScriptTableSave module at run time
  18
  19 --*/
  20
  21 #include "SmmScriptSave.h"
  22
  23 //
  24 // internal functions
  25 //
  26
  27 EFI_STATUS
  28 BootScriptIoWrite  (
  29   IN EFI_SMM_SCRIPT_TABLE     *ScriptTable,
  30   IN VA_LIST                  Marker
  31   );
  32
  33 EFI_STATUS
  34 BootScriptPciCfgWrite  (
  35   IN EFI_SMM_SCRIPT_TABLE     *ScriptTable,
  36   IN VA_LIST                  Marker
  37   );
  38
  39 VOID
  40 SmmCopyMem (
  41   IN  UINT8    *Destination,
  42   IN  UINT8    *Source,
  43   IN  UINTN    ByteCount
  44   );
  45
  46 //
  47 // Function implementations
  48 //
  49 EFI_STATUS
  50 SmmBootScriptWrite (
  51   IN OUT EFI_SMM_SCRIPT_TABLE    *ScriptTable,
  52   IN UINTN                       Type,
  53   IN UINT16                      OpCode,
  54   ...
  55   )
  56 {
  57   EFI_STATUS    Status;
  58   VA_LIST       Marker;
  59
  60   if (ScriptTable == NULL) {
  61     return EFI_INVALID_PARAMETER;
  62   }
  63
  64   //
  65   // Build script according to opcode
  66   //
  67   switch ( OpCode ) {
  68
  69     case EFI_BOOT_SCRIPT_IO_WRITE_OPCODE:
  70       VA_START(Marker, OpCode);
  71       Status = BootScriptIoWrite (ScriptTable, Marker);
  72       VA_END(Marker);
  73       break;
  74
  75     case EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE_OPCODE:
  76       VA_START(Marker, OpCode);
  77       Status = BootScriptPciCfgWrite(ScriptTable, Marker);
  78       VA_END(Marker);
  79       break;
  80
  81     default:
  82       Status = EFI_SUCCESS;
  83       break;
  84   }
  85
  86   return Status;
  87 }
  88
  89
  90 EFI_STATUS
  91 SmmBootScriptCreateTable (
  92   IN OUT EFI_SMM_SCRIPT_TABLE    *ScriptTable,
  93   IN UINTN                       Type
  94   )
  95 {
  96   BOOT_SCRIPT_POINTERS          Script;
  97   UINT8                         *Buffer;
  98
  99   if (ScriptTable == NULL) {
 100     return EFI_INVALID_PARAMETER;
 101   }
 102
 103   Buffer = (UINT8*) ((UINTN)(*ScriptTable));
 104
 105   //
 106   // Fill Table Header
 107   //
 108   Script.Raw = Buffer;
 109   Script.TableInfo->OpCode      = EFI_BOOT_SCRIPT_TABLE_OPCODE;
 110   Script.TableInfo->Length      = sizeof(EFI_BOOT_SCRIPT_TABLE_HEADER);
 111   Script.TableInfo->TableLength = sizeof(EFI_BOOT_SCRIPT_TABLE_HEADER);
 112
 113   //
 114   // Update current table pointer
 115   //
 116   *ScriptTable = *ScriptTable + sizeof(EFI_BOOT_SCRIPT_TABLE_HEADER);
 117   return EFI_SUCCESS;
 118 }
 119
 120
 121 EFI_STATUS
 122 SmmBootScriptCloseTable (
 123   IN EFI_SMM_SCRIPT_TABLE        ScriptTableBase,
 124   IN EFI_SMM_SCRIPT_TABLE        ScriptTablePtr,
 125   IN UINTN                       Type
 126   )
 127 {
 128   BOOT_SCRIPT_POINTERS    Script;
 129
 130   //
 131   // Add final "termination" node to script table
 132   //
 133   Script.Raw               = (UINT8*) ((UINTN)ScriptTablePtr);
 134   Script.Terminate->OpCode = EFI_BOOT_SCRIPT_TERMINATE_OPCODE;
 135   Script.Terminate->Length = sizeof (EFI_BOOT_SCRIPT_TERMINATE);
 136   ScriptTablePtr          += sizeof (EFI_BOOT_SCRIPT_TERMINATE);
 137
 138
 139   //
 140   // Update Table Header
 141   //
 142   Script.Raw                    = (UINT8*) ((UINTN)ScriptTableBase);
 143   Script.TableInfo->OpCode      = EFI_BOOT_SCRIPT_TABLE_OPCODE;
 144   Script.TableInfo->Length      = sizeof (EFI_BOOT_SCRIPT_TABLE_HEADER);
 145   Script.TableInfo->TableLength = (UINT32)(ScriptTablePtr - ScriptTableBase);
 146
 147   return EFI_SUCCESS;
 148 }
 149
 150
 151 EFI_STATUS
 152 BootScriptIoWrite  (
 153   IN EFI_SMM_SCRIPT_TABLE     *ScriptTable,
 154   IN VA_LIST                  Marker
 155   )
 156 {
 157   BOOT_SCRIPT_POINTERS    Script;
 158   EFI_BOOT_SCRIPT_WIDTH   Width;
 159   UINTN                   Address;
 160   UINTN                   Count;
 161   UINT8                   *Buffer;
 162   UINTN                   NodeLength;
 163   UINT8                   WidthInByte;
 164
 165   Width     = VA_ARG(Marker, EFI_BOOT_SCRIPT_WIDTH);
 166   Address   = VA_ARG(Marker, UINTN);
 167   Count     = VA_ARG(Marker, UINTN);
 168   Buffer    = VA_ARG(Marker, UINT8*);
 169
 170   WidthInByte = (UINT8)(0x01 << (Width & 0x03));
 171   Script.Raw  = (UINT8*) ((UINTN)(*ScriptTable));
 172   NodeLength  = sizeof (EFI_BOOT_SCRIPT_IO_WRITE) + (WidthInByte * Count);
 173
 174   //
 175   // Build script data
 176   //
 177   Script.IoWrite->OpCode  = EFI_BOOT_SCRIPT_IO_WRITE_OPCODE;
 178   Script.IoWrite->Length  = (UINT8)(NodeLength);
 179   Script.IoWrite->Width   = Width;
 180   Script.IoWrite->Address = Address;
 181   Script.IoWrite->Count   = (UINT32)Count;
 182   SmmCopyMem (
 183     (UINT8*)(Script.Raw + sizeof (EFI_BOOT_SCRIPT_IO_WRITE)),
 184     Buffer,
 185     WidthInByte * Count
 186     );
 187
 188   //
 189   // Update Script table pointer
 190   //
 191   *ScriptTable = *ScriptTable + NodeLength;
 192   return EFI_SUCCESS;
 193 }
 194
 195
 196 EFI_STATUS
 197 BootScriptPciCfgWrite  (
 198   IN EFI_SMM_SCRIPT_TABLE        *ScriptTable,
 199   IN VA_LIST                     Marker
 200   )
 201 {
 202   BOOT_SCRIPT_POINTERS    Script;
 203   EFI_BOOT_SCRIPT_WIDTH   Width;
 204   UINT64                  Address;
 205   UINTN                   Count;
 206   UINT8                   *Buffer;
 207   UINTN                   NodeLength;
 208   UINT8                   WidthInByte;
 209
 210   Width     = VA_ARG(Marker, EFI_BOOT_SCRIPT_WIDTH);
 211   Address   = VA_ARG(Marker, UINT64);
 212   Count     = VA_ARG(Marker, UINTN);
 213   Buffer    = VA_ARG(Marker, UINT8*);
 214
 215   WidthInByte = (UINT8)(0x01 << (Width & 0x03));
 216   Script.Raw  = (UINT8*) ((UINTN)(*ScriptTable));
 217   NodeLength  = sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE) + (WidthInByte * Count);
 218
 219   //
 220   // Build script data
 221   //
 222   Script.PciWrite->OpCode  = EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE_OPCODE;
 223   Script.PciWrite->Length  = (UINT8)(NodeLength);
 224   Script.PciWrite->Width   = Width;
 225   Script.PciWrite->Address = Address;
 226   Script.PciWrite->Count   = (UINT32)Count;
 227   SmmCopyMem (
 228     (UINT8*)(Script.Raw + sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE)),
 229     Buffer,
 230     WidthInByte * Count
 231     );
 232
 233   //
 234   // Update Script table pointer
 235   //
 236   *ScriptTable = *ScriptTable + NodeLength;
 237   return EFI_SUCCESS;
 238 }
 239
 240 VOID
 241 SmmCopyMem (
 242   IN  UINT8    *Destination,
 243   IN  UINT8    *Source,
 244   IN  UINTN    ByteCount
 245   )
 246 {
 247   UINTN   Index;
 248
 249   for (Index = 0; Index < ByteCount; Index++, Destination++, Source++) {
 250     *Destination = *Source;
 251   }
 252 }