summaryrefslogtreecommitdiff
path: root/ReferenceCode/ME/SampleCode/Library/AslUpdate/Dxe/DxeAslUpdateLib.c
blob: 79a7c86aa8a764ff8b8a5d26e250057486119830 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
/** @file
  Boot service DXE ASL update library implementation.
  These functions in this file can be called during DXE and cannot be called during runtime
  or in SMM which should use a RT or SMM library.
  This library uses the ACPI Support protocol.

@copyright
  Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved
  This software and associated documentation (if any) is furnished
  under a license and may only be used or copied in accordance
  with the terms of the license. Except as permitted by such
  license, no part of this software or documentation may be
  reproduced, stored in a retrieval system, or transmitted in any
  form or by any means without the express written consent of
  Intel Corporation.

  This file contains a 'Sample Driver' and is licensed as such
  under the terms of your license agreement with Intel or your
  vendor.  This file may be modified by the user, subject to
  the additional terms of the license agreement

**/
#if !defined(EDK_RELEASE_VERSION) || (EDK_RELEASE_VERSION < 0x00020000)
#include "EdkIIGlueDxe.h"
#include "AslUpdateLib.h"
#endif
static EFI_ACPI_SUPPORT_PROTOCOL  *mAcpiSupport = NULL;
static EFI_ACPI_TABLE_PROTOCOL    *mAcpiTable   = NULL;

//
// Function implemenations
//

/**
  Initialize the ASL update library state.
  This must be called prior to invoking other library functions.

  @param[in] None

  @retval EFI_SUCCESS             The function completed successfully.
**/
EFI_STATUS
InitializeAslUpdateLib (
  VOID
  )
{
  EFI_STATUS  Status;

  ///
  /// Locate ACPI tables
  ///
  Status = gBS->LocateProtocol (&gEfiAcpiSupportProtocolGuid, NULL, (VOID **) &mAcpiSupport);
  ASSERT_EFI_ERROR (Status);
  Status = gBS->LocateProtocol (&gEfiAcpiTableProtocolGuid, NULL, (VOID **) &mAcpiTable);
  return EFI_SUCCESS;
}

/**
  This procedure will update two kinds of asl code.
  1:  Operating Region base address and length.
  2:  Resource Consumption structures in device LDRC.

  @param[in] AslSignature         The signature of Operation Region that we want to update.
  @param[in] BaseAddress          Base address of IO trap.
  @param[in] Length               Length of IO address.

  @retval EFI_SUCCESS             The function completed successfully.
**/
EFI_STATUS
UpdateAslCode (
  IN     UINT32                   AslSignature,
  IN     UINT16                   BaseAddress,
  IN     UINT8                    Length
  )
{
  EFI_STATUS                  Status;
  EFI_ACPI_DESCRIPTION_HEADER *Table;
  EFI_ACPI_TABLE_VERSION      Version;
  UINT8                       *CurrPtr;
  UINT8                       *Operation;
  UINT32                      *Signature;
  UINT8                       *DsdtPointer;
  INTN                        Index;
  UINTN                       Handle;
  UINT16                      AslLength;

  ///
  /// Locate table with matching ID
  ///
  Index     = 0;
  AslLength = 0;
  do {
    Status = mAcpiSupport->GetAcpiTable (mAcpiSupport, Index, (VOID **) &Table, &Version, &Handle);
    if (Status == EFI_NOT_FOUND) {
      break;
    }

    ASSERT_EFI_ERROR (Status);
    Index++;
  } while (Table->Signature != EFI_ACPI_3_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE);

  ///
  /// Fix up the following ASL Code in DSDT:
  /// (1) OperationRegion's IO Base Address and Length.
  /// (2) Resource Consumption in LPC Device.
  ///
  CurrPtr = (UINT8 *) Table;

  ///
  /// Loop through the ASL looking for values that we must fix up.
  ///
  for (DsdtPointer = CurrPtr; DsdtPointer <= (CurrPtr + ((EFI_ACPI_COMMON_HEADER *) CurrPtr)->Length); DsdtPointer++) {
    ///
    /// Get a pointer to compare for signature
    ///
    Signature = (UINT32 *) DsdtPointer;

    ///
    /// Check if this is the signature we are looking for
    ///
    if ((*Signature) == AslSignature) {
      ///
      /// Conditional match.  For Region Objects, the Operator will always be the
      /// byte immediately before the specific name.  Therefore, subtract 1 to check
      /// the Operator.
      ///
      Operation = DsdtPointer - 1;

      ///
      /// If we have an operation region, update the base address and length
      ///
      if (*Operation == AML_OPREGION_OP) {
        ///
        /// Fixup the Base Address in OperationRegion.
        ///
        *(UINT16 *) (DsdtPointer + 6) = BaseAddress;

        ///
        /// Fixup the Length in OperationRegion.
        ///
        *(DsdtPointer + 9) = Length;
      }

    } else if ((*Signature) == EFI_SIGNATURE_32 ('L', 'D', 'R', 'C')) {
      ///
      /// Make sure it's device of LDRC and read the length
      ///
      if (*(DsdtPointer - 2) == AML_DEVICE_OP) {
        AslLength = *(DsdtPointer - 1);
      } else if (*(DsdtPointer - 3) == AML_DEVICE_OP) {
        AslLength = *(UINT16 *) (DsdtPointer - 2);
        AslLength = (AslLength & 0x0F) + ((AslLength & 0x0FF00) >> 4);
      }
      ///
      /// Conditional match.  Search _CSR in Device (LDRC).
      ///
      for (Operation = DsdtPointer; Operation <= DsdtPointer + AslLength; Operation++) {
        ///
        /// Get a pointer to compare for signature
        ///
        Signature = (UINT32 *) Operation;

        ///
        /// Check if this is the signature we are looking for
        ///
        if ((*Signature) == EFI_SIGNATURE_32 ('_', 'C', 'R', 'S')) {
          ///
          /// Now look for an empty resource entry, fix the base address and length fields
          ///
          for (Index = 0; *(UINT16 *) (Operation + 9 + 8 * Index) != 0x0079; Index++) {
            if (*(UINT16 *) (Operation + 11 + 8 * Index) == UINT16_BIT_MAGIC_NUMBER) {
              ///
              /// Fixup the Base Address and Length.
              ///
              *(UINT16 *) (Operation + 11 + 8 * Index)  = BaseAddress;
              *(UINT16 *) (Operation + 13 + 8 * Index)  = BaseAddress;
              *(Operation + 16 + 8 * Index)             = Length;
              break;
            }
          }
        }
      }

      DsdtPointer = DsdtPointer + AslLength;
    }
  }
  ///
  /// Update the modified ACPI table
  ///
  Status = mAcpiTable->InstallAcpiTable (
                                  mAcpiTable,
                                  Table,
                                  Table->Length,
                                  &Handle
                                  );
  FreePool (Table);

  return EFI_SUCCESS;
}

/**
  This function uses the ACPI support protocol to locate an ACPI table.
  It is really only useful for finding tables that only have a single instance,
  e.g. FADT, FACS, MADT, etc.  It is not good for locating SSDT, etc.

  @param[in] Signature            Pointer to an ASCII string containing the OEM Table ID from the ACPI table header
  @param[in] Table                Updated with a pointer to the table
  @param[in] Handle               AcpiSupport protocol table handle for the table found
  @param[in] Version              The version of the table desired

  @retval EFI_SUCCESS             The function completed successfully.
**/
EFI_STATUS
LocateAcpiTableBySignature (
  IN      UINT32                        Signature,
  IN OUT  EFI_ACPI_DESCRIPTION_HEADER   **Table,
  IN OUT  UINTN                         *Handle,
  IN OUT  EFI_ACPI_TABLE_VERSION        *Version
  )
{
  EFI_STATUS              Status;
  INTN                    Index;
  EFI_ACPI_TABLE_VERSION  DesiredVersion;

  DesiredVersion = *Version;
  ///
  /// Locate table with matching ID
  ///
  Index = 0;
  do {
    Status = mAcpiSupport->GetAcpiTable (mAcpiSupport, Index, (VOID **) Table, Version, Handle);
    if (Status == EFI_NOT_FOUND) {
      break;
    }

    ASSERT_EFI_ERROR (Status);
    Index++;
  } while ((*Table)->Signature != Signature || !(*Version & DesiredVersion));

  ///
  /// If we found the table, there will be no error.
  ///
  return Status;
}

/**
  This function uses the ACPI support protocol to locate an ACPI SSDT table.

  @param[in] TableId              Pointer to an ASCII string containing the OEM Table ID from the ACPI table header
  @param[in] TableIdSize          Length of the TableId to match.  Table ID are 8 bytes long, this function
                                  will consider it a match if the first TableIdSize bytes match
  @param[in] Table                Updated with a pointer to the table
  @param[in] Handle               AcpiSupport protocol table handle for the table found
  @param[in] Version              See AcpiSupport protocol, GetAcpiTable function for use

  @retval EFI_SUCCESS             The function completed successfully.
**/
EFI_STATUS
LocateAcpiTableByOemTableId (
  IN      UINT8                         *TableId,
  IN      UINT8                         TableIdSize,
  IN OUT  EFI_ACPI_DESCRIPTION_HEADER   **Table,
  IN OUT  UINTN                         *Handle,
  IN OUT  EFI_ACPI_TABLE_VERSION        *Version
  )
{
  EFI_STATUS  Status;
  INTN        Index;

  ///
  /// Locate table with matching ID
  ///
  Index = 0;
  do {
    Status = mAcpiSupport->GetAcpiTable (mAcpiSupport, Index, (VOID **) Table, Version, Handle);
    if (Status == EFI_NOT_FOUND) {
      break;
    }

    ASSERT_EFI_ERROR (Status);
    Index++;
  } while (CompareMem (&(*Table)->OemTableId, TableId, TableIdSize));

  ///
  /// If we found the table, there will be no error.
  ///
  return Status;
}

/**
  This function calculates and updates an UINT8 checksum.

  @param[in] Buffer               Pointer to buffer to checksum
  @param[in] Size                 Number of bytes to checksum
  @param[in] ChecksumOffset       Offset to place the checksum result in

  @retval EFI_SUCCESS             The function completed successfully.
**/
EFI_STATUS
AcpiChecksum (
  IN VOID                         *Buffer,
  IN UINTN                        Size,
  IN UINTN                        ChecksumOffset
  )
{
  UINT8 Sum;
  UINT8 *Ptr;

  Sum = 0;
  //
  // Initialize pointer
  //
  Ptr = Buffer;

  //
  // Set checksum to 0 first
  //
  Ptr[ChecksumOffset] = 0;

  //
  // Add all content of buffer
  //
  while (Size--) {
    Sum = (UINT8) (Sum + (*Ptr++));
  }
  //
  // Set checksum
  //
  Ptr                 = Buffer;
  Ptr[ChecksumOffset] = (UINT8) (0xff - Sum + 1);

  return EFI_SUCCESS;
}