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
/** @file
 
 @copyright
  Copyright 2018 - 2021 Intel Corporation.
 
  SPDX-License-Identifier: BSD-2-Clause-Patent
**/
 
 
/**
  The constructor function for Board Init Libray.
 
  @param  FileHandle  Handle of the file being invoked.
  @param  PeiServices Describes the list of possible PEI Services.
 
  @retval  EFI_SUCCESS            Table initialization successfully.
  @retval  EFI_OUT_OF_RESOURCES   No enough memory to initialize table.
**/
 
#include "PeiBoardInit.h"
#include <UncoreCommonIncludes.h>
#include <Library/PchMultiPchBase.h>
#include <Ppi/DynamicSiLibraryPpi.h>
 
 
/**
 
  Identifies platform capabilites if the platform is a 2-socket standalone
  modular board, or a 4-socket modular boards, or 8-socket modular boards.
 
  @param[in,out] PlatformCapabilities    Holds the information about platform being
                                         a standalone 2S, or 4S/8S modular boards.
 
  @retval EFI_SUCCESS  Platform Capabilities is updated.
 
**/
EFI_STATUS
GetPlatformCapabilitiesInfo (
  IN OUT UINT8                 *PlatformCapabilities,
  IN DYNAMIC_SI_LIBARY_PPI     *DynamicSiLibraryPpi
  )
{
  GPIO_CONFIG          PadConfig;
  UINT32               GpioState;
  EFI_STATUS           Status = EFI_SUCCESS;
 
  *PlatformCapabilities = PLATFORM_CAPABILITY_UNDEFINED;
 
  PadConfig.PadMode          = GpioPadModeGpio;
  PadConfig.HostSoftPadOwn   = GpioHostOwnGpio;
  PadConfig.Direction        = GpioDirIn;
  PadConfig.OutputState      = GpioOutDefault;
  PadConfig.InterruptConfig  = GpioIntDefault;
  PadConfig.PowerConfig      = GpioResetDefault;
  PadConfig.ElectricalConfig = GpioTermDefault;
  PadConfig.LockConfig       = GpioLockDefault;
  PadConfig.OtherSettings    = GpioRxRaw1Default;
 
  //
  // GPP_D6 is standalone signal. GPP_D7 is 4S/8S signal.
  //   GPP_D7     |  GPP_D6
  //  =======================
  //   Don't care |    0   (2-socket)
  //       1      |    1   (4-socket)
  //       0      |    1   (8-socket)
  //
 
  if (DynamicSiLibraryPpi->IsSimicsEnvironment ()) {
    //
    // Workaround until GPIO pins new definition are implemented in Simics
    //
    *PlatformCapabilities = PLATFORM_CAPABILITY_8_SOCKET;
    return EFI_SUCCESS;
  }
 
  Status = DynamicSiLibraryPpi->GpioSetPadConfigByPchId (PCH_LEGACY_ID, GPIO_SKL_H_GPP_D6, &PadConfig);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = DynamicSiLibraryPpi->GpioGetInputValueByPchId (PCH_LEGACY_ID, GPIO_SKL_H_GPP_D6, &GpioState);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  DEBUG ((DEBUG_INFO, "GPP_D6:%d\n", GpioState));
 
  if (GpioState == 0) {
    *PlatformCapabilities = PLATFORM_CAPABILITY_2_SOCKET;
    return Status;
  }
 
  Status = DynamicSiLibraryPpi->GpioSetPadConfigByPchId (PCH_LEGACY_ID, GPIO_SKL_H_GPP_D7, &PadConfig);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = DynamicSiLibraryPpi->GpioGetInputValueByPchId (PCH_LEGACY_ID, GPIO_SKL_H_GPP_D7, &GpioState);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  DEBUG ((DEBUG_INFO, "GPP_D7:%d\n", GpioState));
 
  *PlatformCapabilities = (GpioState == 1) ? PLATFORM_CAPABILITY_4_SOCKET : PLATFORM_CAPABILITY_8_SOCKET;
 
  return Status;
}
 
 
EFI_STATUS
EFIAPI
TypeCooperCityRPPeiBoardInitLibConstructor (
  IN EFI_PEI_FILE_HANDLE     FileHandle,
  IN CONST EFI_PEI_SERVICES  **PeiServices
  )
{
  EFI_STATUS                      Status = EFI_SUCCESS;
  UBA_CONFIG_DATABASE_PPI         *UbaConfigPpi;
  DYNAMIC_SI_LIBARY_PPI           *DynamicSiLibraryPpi = NULL;
  EFI_HOB_GUID_TYPE               *GuidHob;
  EFI_PLATFORM_INFO               *PlatformInfo;
  UINT8                           SocketIndex;
  CONST CHAR8                     *Str;
 
  GuidHob       = GetFirstGuidHob (&gEfiPlatformInfoGuid);
  ASSERT (GuidHob != NULL);
  if (GuidHob == NULL) {
    return EFI_NOT_FOUND;
  }
  PlatformInfo  = GET_GUID_HOB_DATA(GuidHob);
 
  if (PlatformInfo->BoardId == TypeCooperCityRP) {
 
    DEBUG ((DEBUG_INFO, "PEI UBA init BoardId 0x%X: CooperCityRP\n", PlatformInfo->BoardId));
 
    PlatformInfo->MaxNumOfPchs = 4;
    ASSERT (PlatformInfo->MaxNumOfPchs <= PCH_MAX);
 
    Status = PeiServicesLocatePpi (
              &gUbaConfigDatabasePpiGuid,
              0,
              NULL,
              &UbaConfigPpi
              );
    if (EFI_ERROR(Status)) {
      return Status;
    }
 
    Status = PeiServicesLocatePpi (&gDynamicSiLibraryPpiGuid, 0, NULL, &DynamicSiLibraryPpi);
    if (EFI_ERROR (Status)) {
      ASSERT_EFI_ERROR (Status);
      return Status;
    }
 
    Status = UbaConfigPpi->InitSku (
                       UbaConfigPpi,
                       PlatformInfo->BoardId,
                       NULL,
                       NULL
                       );
    ASSERT_EFI_ERROR (Status);
 
    Status = TypeCooperCityRPInstallGpioData (UbaConfigPpi);
    if (EFI_ERROR(Status)) {
      return Status;
    }
 
    Status = TypeCooperCityRPInstallPcdData (UbaConfigPpi);
    if (EFI_ERROR(Status)) {
      return Status;
    }
 
    Status = TypeCooperCityRPInstallSoftStrapData (UbaConfigPpi);
    if (EFI_ERROR(Status)) {
      return Status;
    }
 
    Status = TypeCooperCityRPPchEarlyUpdate (UbaConfigPpi);
    if (EFI_ERROR(Status)) {
      return Status;
    }
 
    Status = TypeCooperCityRPPlatformUpdateUsbOcMappings (UbaConfigPpi);
    if (EFI_ERROR(Status)) {
      return Status;
    }
 
    Status = TypeCooperCityRPIioPortBifurcationInit (UbaConfigPpi);
    if (EFI_ERROR(Status)) {
      return Status;
    }
 
    Status = TypeCooperCityRPInstallSlotTableData (UbaConfigPpi);
    if (EFI_ERROR(Status)) {
      return Status;
    }
 
    //
    // Set default memory type connector to DimmConnectorSmt
    //
    (*PeiServices)->SetMem (&PlatformInfo->MemoryConnectorType, sizeof (PlatformInfo->MemoryConnectorType), DimmConnectorSmt);
 
    //
    // Initialize InterposerType to InterposerUnknown
    //
    for (SocketIndex = 0; SocketIndex < MAX_SOCKET; ++SocketIndex) {
      PlatformInfo->InterposerType[SocketIndex] = InterposerUnknown;
    }
 
    GetPlatformCapabilitiesInfo (&PlatformInfo->PlatformCapabilities, DynamicSiLibraryPpi);
 
    Str = (PlatformInfo->PlatformCapabilities <= PLATFORM_CAPABILITY_8_SOCKET) ? \
          PlatformCapabilitiesStr[PlatformInfo->PlatformCapabilities] : PlatformCapabilitiesStr[PLATFORM_CAPABILITY_UNDEFINED];
    DEBUG ((DEBUG_INFO, "PlatformCapabilities = %a\n", Str));
 
    Status = TypeCooperCityRPInstallKtiEparamData (UbaConfigPpi, PlatformInfo->PlatformCapabilities);
    if (EFI_ERROR(Status)) {
      return Status;
    }
  }
 
  return Status;
}