hc
2024-03-25 edb30157bad0c0001c32b854271ace01d3b9a16a
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
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
/** @file
  UBS silicon access PPI
 
  This PPI abstracts all UBA silicon accesses
 
  @copyright
  Copyright 2021 Intel Corporation. <BR>
 
  SPDX-License-Identifier: BSD-2-Clause-Patent
**/
 
#ifndef _DYNAMIC_SI_LIBARY_PPI_H_
#define _DYNAMIC_SI_LIBARY_PPI_H_
 
// {C1176733-159F-42d5-BCB9-320660B17310}
#define DYNAMIC_SI_LIBARY_PPI_GUID \
  { 0x4e18e22b, 0x5034, 0x4512, { 0xb7, 0xe5, 0x0b, 0xf1, 0x9d, 0xe3, 0x59, 0x8c } }
 
#define UBA_ACCESS_PPI_VERSION    01
#define UBA_ACCESS_PPI_SIGNATURE  SIGNATURE_32('D', 'S', 'L', 'P')
 
#include <Library/SpsPeiLib.h>
#include <IioPlatformData.h>
#include <GpioConfig.h>
#include <Library/PchInfoLib.h>
#include <Library/GpioLib.h>
 
//
// Functions
//
 
typedef
EFI_STATUS
(EFIAPI *PEI_GET_GPIO_INPUT_VALUE) (
  IN  GPIO_PAD                            GpioPad,
  OUT UINT32                              *InputVal
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_SET_GPIO_OUTPUT_VALUE) (
  IN  GPIO_PAD                            GpioPad,
  IN  UINT32                              Value
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_GPIO_SET_PAD) (
  IN  GPIO_PAD                            GpioPad,
  IN  GPIO_CONFIG                         *GpioData
  );
 
typedef
UINT16
(EFIAPI *PEI_GET_PCH_DEVICE_ID) (
  VOID
  );
 
typedef
PCH_SERIES
(EFIAPI *PEI_GET_PCH_SERIES) (
  VOID
  );
 
typedef
PCH_STEPPING
(EFIAPI *PEI_GET_PCH_STEPPING) (
  VOID
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_IS_PCH_GBE_REGION_VALID) (
  VOID
  );
 
typedef
UINT32
(EFIAPI *PEI_GET_PCH_GBE_PORT_NUMBER) (
  VOID
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_IS_PCH_GBE_PRESENT) (
  VOID
  );
 
typedef
VOID
(EFIAPI *PEI_PchDisableGbe) (
  VOID
  );
 
typedef
VOID
(EFIAPI *PEI_PchDisableGbeByPchId) (
  IN  UINT8           PchId
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_GpioConfigurePadsByPchId) (
  IN UINT8                     PchId,
  IN UINT32                    NumberOfItems,
  IN GPIO_INIT_CONFIG          *GpioInitTableAddress
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_GpioGetInputValueByPchId) (
  IN UINT8                     PchId,
  IN GPIO_PAD                  GpioPad,
  OUT UINT32                   *InputVal
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_PeiGetCurrenClockingMode) (
   OUT CLOCKING_MODES *ClockingMode
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_GetPchPcieRpDevFunByPchId) (
  IN  UINT8   PchId,
  IN  UINTN   RpNumber,
  OUT UINTN   *RpDev,
  OUT UINTN   *RpFun
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_IsSimicsEnvironment) (
  VOID
  );
 
typedef
UINT8
(EFIAPI *PEI_GetPchMaxSataPortNum) (
  VOID
  );
 
typedef
UINT8
(EFIAPI *PEI_GetPchMaxsSataPortNum) (
  VOID
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_GpioSetPadConfigByPchId) (
  IN UINT8                     PchId,
  IN GPIO_PAD                  GpioPad,
  IN GPIO_CONFIG               *GpioData
  );
 
typedef
UINT8
(EFIAPI *PEI_GetPchMaxPciePortNum) (
  VOID
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_PchGetSataLaneNumByPchId) (
  IN  UINT8           PchId,
  UINT32              SataLaneIndex,
  UINT8               *LaneNum
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_PchGetPcieLaneNumByPchId) (
  IN  UINT8           PchId,
  UINT32              PcieLaneIndex,
  UINT8               *LaneNum
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_PchGetsSataLaneNumByPchId) (
  IN  UINT8           PchId,
  UINT32              SataLaneIndex,
  UINT8               *LaneNum
  );
 
typedef
UINTN
(EFIAPI *PEI_MmPciBase) (
  IN UINT32                       Bus,
  IN UINT32                       Device,
  IN UINT32                       Function
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_HybridSystemLevelEmulationEnabled) (
  VOID
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_IioIsSocketPresent) (
  IN  UINT8  IioIndex
  );
 
typedef
UINT8
(EFIAPI *PEI_GetMaxPortNumPerSocket) (
  VOID
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_IsVMDEnabledForPort) (
  IN  UINT8              IioIndex,
  IN  UINT8              PortIndex
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_IioAreLanesAssignedToPort) (
  IN  IIO_GLOBALS  *IioGlobalData,
  IN  UINT8        IioIndex,
  IN  UINT8        PortIndex
  );
 
typedef
UINT8
(EFIAPI *PEI_GetPortIndexbyStack) (
  IN UINT8    StackIndex,
  IN UINT8    PortIndex
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_IsDmiStack) (
  IN  UINT8             Stack
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_IsCpuAndRevision) (
  IN UINT8  CpuType,
  IN UINT16 Revision
  );
 
typedef
UINT8
(EFIAPI *PEI_GetMaxStackNumPerSocket) (
  VOID
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_IioIsStackPresent) (
  IN UINT8     IioIndex,
  IN UINT8     StackIndex
  );
 
typedef
UINT8
(EFIAPI *PEI_GetMaxPortNumPerStack) (
  IN  UINT8   Stack
  );
 
//
// From KtiApi.h
//
typedef
BOOLEAN
(EFIAPI *PEI_SocketPresent) (
  IN UINT32     SocId
  );
 
/**
  Get SVID Mapping from Socket and MCID
 
  @param[in] Socket    - Socket Id - 0 based
  @param[in] McId      - Memory controller 0 based
  @param[in] SvidValue - SVID Value
 
  @retval EFI_SUCCESS   - Value found
  @retval EFI_NOT_FOUND - Value not found
 
**/
typedef
EFI_STATUS
(EFIAPI *PEI_GetSvidMap) (
  IN UINT8 Socket,
  IN UINT8 McId,
  IN UINT8 *SvidValue
  );
 
typedef
UINT16
(EFIAPI *PEI_PmcGetAcpiBase) (
  VOID
  );
 
typedef
UINT16
(EFIAPI *PEI_PmcGetAcpiBaseByPchId) (
  IN  UINT8           PchId
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_PchLpcIoDecodeRangesSet) (
  IN  UINT16                            LpcIoDecodeRanges
  );
 
typedef
VOID
(EFIAPI *PEI_CheckPowerOffNow) (
  VOID
  );
 
typedef
VOID
(EFIAPI *PEI_PmcSetPlatformStateAfterPowerFailure) (
  IN UINT8 PowerStateAfterG3
  );
 
typedef
VOID
(EFIAPI *PEI_PmcClearPowerFailureStatus) (
  VOID
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_PmcIsPowerFailureDetected) (
  VOID
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_PchLpcGenIoRangeSet) (
  IN  UINT16                            Address,
  IN  UINTN                             Length
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_PchLpcIoEnableDecodingSet) (
  IN  UINT16                            LpcIoEnableDecoding
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_PchPcrAndThenOr32) (
  IN  PCH_SBI_PID                       Pid,
  IN  UINT16                            Offset,
  IN  UINT32                            AndData,
  IN  UINT32                            OrData
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_PchPcrRead32ByPchId) (
  IN  UINT8                             PchId,
  IN  PCH_SBI_PID                       Pid,
  IN  UINT16                            Offset,
  OUT UINT32                            *OutData
  );
 
typedef
UINT8
(EFIAPI *PEI_ReadNmiEn) (
  VOID
  );
 
typedef
UINT8
(EFIAPI *PEI_GetPchXhciMaxUsb2PortNum) (
  VOID
  );
 
typedef
UINT8
(EFIAPI *PEI_GetPchXhciMaxUsb3PortNum) (
  VOID
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_PchIsGbeAvailable) (
  VOID
  );
 
typedef
EFI_STATUS
(EFIAPI *PEI_EnableMcaOnCacheableMmio) (
  VOID
  );
 
typedef
BOOLEAN
(EFIAPI *PEI_X2ApicIdDetect) (
  IN VOID  *Host
  );
 
//
// Abstracting silicon functional implementations from OpenBoardPkg code
//
typedef struct {
  UINT32                                    Signature;
  UINT32                                    Version;
 
  PEI_GET_GPIO_INPUT_VALUE                  GpioGetInputValue;
  PEI_SET_GPIO_OUTPUT_VALUE                 GpioSetOutputValue;
  PEI_GPIO_SET_PAD                          GpioSetPadConfig;
 
  PEI_GET_PCH_DEVICE_ID                     GetPchLpcDeviceId;
  PEI_GET_PCH_SERIES                        GetPchSeries;
  PEI_GET_PCH_STEPPING                      PchStepping;
  PEI_IS_PCH_GBE_REGION_VALID               PchIsGbeRegionValid;
  PEI_GET_PCH_GBE_PORT_NUMBER               PchGetGbePortNumber;
  PEI_IS_PCH_GBE_PRESENT                    PchIsGbePresent;
 
  PEI_PchDisableGbeByPchId                  PchDisableGbeByPchId;
  PEI_GpioConfigurePadsByPchId              GpioConfigurePadsByPchId;
  PEI_GpioSetPadConfigByPchId               GpioSetPadConfigByPchId;
  PEI_GpioGetInputValueByPchId              GpioGetInputValueByPchId;
  PEI_PeiGetCurrenClockingMode              PeiGetCurrenClockingMode;
  PEI_GetPchPcieRpDevFunByPchId             GetPchPcieRpDevFunByPchId;
  PEI_IsSimicsEnvironment                   IsSimicsEnvironment;
  PEI_GetPchMaxSataPortNum                  GetPchMaxSataPortNum;
  PEI_GetPchMaxsSataPortNum                 GetPchMaxsSataPortNum;
  PEI_GetPchMaxPciePortNum                  GetPchMaxPciePortNum;
  PEI_PchGetSataLaneNumByPchId              PchGetSataLaneNumByPchId;
  PEI_PchGetsSataLaneNumByPchId             PchGetsSataLaneNumByPchId;
  PEI_PchGetPcieLaneNumByPchId              PchGetPcieLaneNumByPchId;
  PEI_MmPciBase                             MmPciBase;
  PEI_HybridSystemLevelEmulationEnabled     HybridSystemLevelEmulationEnabled;
  PEI_IioIsSocketPresent                    IioIsSocketPresent;
  PEI_GetMaxPortNumPerSocket                GetMaxPortNumPerSocket;
  PEI_IsVMDEnabledForPort                   IsVMDEnabledForPort;
  PEI_IioAreLanesAssignedToPort             IioAreLanesAssignedToPort;
  PEI_GetPortIndexbyStack                   GetPortIndexbyStack;
  PEI_IsDmiStack                            IsDmiStack;
  PEI_IsCpuAndRevision                      IsCpuAndRevision;
  PEI_PchDisableGbe                         PchDisableGbe;
  PEI_GetMaxStackNumPerSocket               GetMaxStackNumPerSocket;
  PEI_IioIsStackPresent                     IioIsStackPresent;
  PEI_GetMaxPortNumPerStack                 GetMaxPortNumPerStack;
  PEI_SocketPresent                         SocketPresent;
  PEI_GetSvidMap                            GetSvidMap;
 
  PEI_PmcGetAcpiBase                        PmcGetAcpiBase;
  PEI_PmcGetAcpiBaseByPchId                 PmcGetAcpiBaseByPchId;
  PEI_PchLpcIoDecodeRangesSet               PchLpcIoDecodeRangesSet;
  PEI_CheckPowerOffNow                      CheckPowerOffNow;
  PEI_PmcSetPlatformStateAfterPowerFailure  PmcSetPlatformStateAfterPowerFailure;
  PEI_PmcClearPowerFailureStatus            PmcClearPowerFailureStatus;
  PEI_PmcIsPowerFailureDetected             PmcIsPowerFailureDetected;
  PEI_PchLpcGenIoRangeSet                   PchLpcGenIoRangeSet;
  PEI_PchLpcIoEnableDecodingSet             PchLpcIoEnableDecodingSet;
  PEI_PchPcrAndThenOr32                     PchPcrAndThenOr32;
  PEI_PchPcrRead32ByPchId                   PchPcrRead32ByPchId;
  PEI_ReadNmiEn                             ReadNmiEn;
 
  PEI_GetPchXhciMaxUsb2PortNum              GetPchXhciMaxUsb2PortNum;
  PEI_GetPchXhciMaxUsb3PortNum              GetPchXhciMaxUsb3PortNum;
  PEI_PchIsGbeAvailable                     PchIsGbeAvailable;
  PEI_EnableMcaOnCacheableMmio              EnableMcaOnCacheableMmio;
  PEI_X2ApicIdDetect                        X2ApicIdDetect;
} DYNAMIC_SI_LIBARY_PPI;
 
extern EFI_GUID gDynamicSiLibraryPpiGuid;
 
#endif // _DYNAMIC_SI_LIBARY_PPI_H_