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
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
|
/** @file
Copyright (c) 2018, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include <PiDxe.h>
#include <Protocol/IioUds.h>
#include <PciPlatform.h>
#include <PciPlatformHooks.h>
#include <PciSupportLib.h>
#include <IoApic.h>
#include <Library/S3BootScriptLib.h>
#include <Protocol/IioSystem.h>
EFI_IIO_UDS_PROTOCOL *mIioUds = NULL;
EFI_IIO_SYSTEM_PROTOCOL *IioSystemProtocol = NULL;
IIO_GLOBALS *IioGlobalData = NULL;
VOID
ChipsetCallback (
IN EFI_HANDLE RootBridgeHandle,
IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS PciAddress,
IN EFI_PCI_ENUMERATION_PHASE Phase,
EFI_PCI_CALLBACK_CONTEXT *Context
)
{
EFI_LIST_ENTRY *NodeEntry;
PCI_CALLBACK_DATA *PciCallbackData;
//
// Check if the node has been added
//
// DEBUG ((DEBUG_ERROR, "PCI Callback (%d,%d,%d)\n",PciAddress.Bus, PciAddress.Device, PciAddress.Function ));
//
Context->PciRootBridgeIo = mPciPrivateData.PciRootBridgeIo;
NodeEntry = GetFirstNode (&mPciPrivateData.PciCallbackList);
while (!IsNull (&mPciPrivateData.PciCallbackList, NodeEntry)) {
PciCallbackData = PCI_CALLBACK_DATA_FROM_LINK (NodeEntry);
if (PciCallbackData->Phase & Phase) {
(PciCallbackData->Function) (RootBridgeHandle, PciAddress, Phase, Context);
}
NodeEntry = GetNextNode (&mPciPrivateData.PciCallbackList, NodeEntry);
}
}
/**
GC_TODO: add routine description
@param StartBus - GC_TODO: add arg description
@retval EFI_SUCCESS - GC_TODO: add retval description
**/
EFI_STATUS
PciTreeTraverse (
IN UINT8 StartBus
)
{
UINT64 PciAddress;
UINT8 Device;
UINT8 Func;
UINT8 SecondaryBus;
BOOLEAN MultiFunc;
for (Device = 0; Device <= PCI_MAX_DEVICE; Device++) {
MultiFunc = FALSE;
for (Func = 0; Func <= PCI_MAX_FUNC; Func++) {
if (IsPciDevicePresent (
mPciPrivateData.PciRootBridgeIo,
&mPciPrivateData.Context.PciHeader,
StartBus,
Device,
Func
)) {
if ((Func == 0) && IS_PCI_MULTI_FUNC(&(mPciPrivateData.Context.PciHeader))) {
MultiFunc = TRUE;
}
PciAddress = EFI_PCI_ADDRESS (StartBus, Device, Func, 0);
ChipsetCallback (
mPciPrivateData.RootBridgeHandle,
*(EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS *) &PciAddress,
mPciPrivateData.PciEnumerationPhase,
&(mPciPrivateData.Context)
);
if (IS_PCI_BRIDGE (&(mPciPrivateData.Context.PciHeader))) {
PciAddress = EFI_PCI_ADDRESS (StartBus, Device, Func, PCI_BRIDGE_SECONDARY_BUS_REGISTER_OFFSET);
mPciPrivateData.PciRootBridgeIo->Pci.Read (
mPciPrivateData.PciRootBridgeIo,
EfiPciWidthUint8,
*(UINT64 *) &PciAddress,
1,
&SecondaryBus
);
if ((SecondaryBus > 0) && (SecondaryBus < 0xFF)) {
PciTreeTraverse (SecondaryBus);
}
}
}
if (MultiFunc == FALSE) {
//
// Skip sub functions, this is not a multi function device
//
Func = PCI_MAX_FUNC;
}
}
}
return EFI_SUCCESS;
}
/**
Program Io Apic Id
@param IoApicAddress and IoApicId
@retval None
**/
VOID
ProgramIoApicId (
IN UINT32 IoApicAddress,
IN UINT8 IoApicId
)
{
UINT32 Data;
mPciPrivateData.CpuIo->Mem.Read (
mPciPrivateData.CpuIo,
EfiCpuIoWidthUint32,
IoApicAddress + EFI_IO_APIC_INDEX_OFFSET,
1,
&Data
);
//
// IOAPIC is not there
//
if (Data == (UINT32) -1) {
return ;
}
//
// Set up IO APIC ID and enable FSB delivery
// Use CPU IO protocol since the IO APIC ranges
// are not included in PCI apertures
//
Data = EFI_IO_APIC_ID_REGISTER;
mPciPrivateData.CpuIo->Mem.Write (
mPciPrivateData.CpuIo,
EfiCpuIoWidthUint32,
IoApicAddress + EFI_IO_APIC_INDEX_OFFSET,
1,
&Data
);
Data = IoApicId << EFI_IO_APIC_ID_BITSHIFT;
mPciPrivateData.CpuIo->Mem.Write (
mPciPrivateData.CpuIo,
EfiCpuIoWidthUint32,
IoApicAddress + EFI_IO_APIC_DATA_OFFSET,
1,
&Data
);
Data = EFI_IO_APIC_BOOT_CONFIG_REGISTER;
mPciPrivateData.CpuIo->Mem.Write (
mPciPrivateData.CpuIo,
EfiCpuIoWidthUint32,
IoApicAddress + EFI_IO_APIC_INDEX_OFFSET,
1,
&Data
);
Data = EFI_IO_APIC_FSB_INT_DELIVERY;
mPciPrivateData.CpuIo->Mem.Write (
mPciPrivateData.CpuIo,
EfiCpuIoWidthUint32,
IoApicAddress + EFI_IO_APIC_DATA_OFFSET,
1,
&Data
);
}
#ifdef EFI_PCI_IOV_SUPPORT
/**
Initialize the Pci Iov Platform Data.
@param ImageHandle - Handle to the image.
@param SystemTable - Handle to System Table.
@retval EFI_STATUS - Status of the function calling.
**/
EFI_STATUS
EFIAPI
PciPlatformInitPciIovData (
VOID
)
{
EFI_STATUS Status;
EFI_PCI_IOV_PLATFORM_POLICY PciIovPolicy;
UINT32 SystemPageSize;
EFI_PCI_IOV_PLATFORM_PROTOCOL *gPciIovPlatformProtocol;
Status = gBS->LocateProtocol (
&gEfiPciIovPlatformProtocolGuid,
NULL,
&gPciIovPlatformProtocol
);
if (!EFI_ERROR (Status)) {
Status = gPciIovPlatformProtocol->GetSystemLowestPageSize (
gPciIovPlatformProtocol,
&SystemPageSize
);
if (!EFI_ERROR (Status)) {
Status = PcdSet32S (PcdSrIovSystemPageSize, (1 << SystemPageSize));
ASSERT_EFI_ERROR (Status);
if (EFI_ERROR(Status)) return Status;
} else {
return Status;
}
Status = gPciIovPlatformProtocol->GetPlatformPolicy (
gPciIovPlatformProtocol,
&PciIovPolicy
);
if (!EFI_ERROR (Status)) {
if (PciIovPolicy & EFI_PCI_IOV_POLICY_ARI) {
Status = PcdSetBoolS (PcdAriSupport, TRUE);
ASSERT_EFI_ERROR (Status);
if (EFI_ERROR(Status)) return Status;
} else {
Status = PcdSetBoolS (PcdAriSupport, FALSE);
ASSERT_EFI_ERROR (Status);
if (EFI_ERROR(Status)) return Status;
}
if (PciIovPolicy & EFI_PCI_IOV_POLICY_SRIOV) {
Status = PcdSetBoolS (PcdSrIovSupport, TRUE);
ASSERT_EFI_ERROR (Status);
if (EFI_ERROR(Status)) return Status;
} else {
Status = PcdSetBoolS (PcdSrIovSupport, FALSE);
ASSERT_EFI_ERROR (Status);
if (EFI_ERROR(Status)) return Status;
}
if (PciIovPolicy & EFI_PCI_IOV_POLICY_MRIOV) {
Status = PcdSetBoolS (PcdMrIovSupport, TRUE);
ASSERT_EFI_ERROR (Status);
if (EFI_ERROR(Status)) return Status;
} else {
Status = PcdSetBoolS (PcdMrIovSupport, FALSE);
ASSERT_EFI_ERROR (Status);
if (EFI_ERROR(Status)) return Status;
}
} else {
return Status;
}
DEBUG ((
EFI_D_INFO,
" Initialized SR-IOV Platform Data: PCIIovPolicy = 0x%x; SystemPageSize = 0x%x;\n",
PciIovPolicy, SystemPageSize
));
} else {
DEBUG ((
EFI_D_INFO,
" Using default values for SystemPageSize;\n"
));
}
return Status;
}
#endif
/**
Platform Pci Express init.
@param HostBridgeInstance - Pointer to Host Bridge private data
does not support 64 bit memory addresses.
@retval EFI_SUCCESS - Success.
**/
EFI_STATUS
PciPlatformEarlyInit (
VOID
)
{
EFI_STATUS Status;
//
// Locate the IIO Protocol Interface
//
Status = gBS->LocateProtocol (&gEfiIioUdsProtocolGuid,NULL,&mIioUds);
ASSERT_EFI_ERROR (Status);
Status = gBS->LocateProtocol (&gEfiIioSystemProtocolGuid, NULL, &IioSystemProtocol);
ASSERT_EFI_ERROR (Status);
IioGlobalData = IioSystemProtocol->IioGlobalData;
#ifdef EFI_PCI_IOV_SUPPORT
Status = PciPlatformInitPciIovData(); // Update IOV PCD values
#endif
return EFI_SUCCESS;
}
/**
Init pci device registers after the device resources have been allocated, so
that devices behind a bus could be accessed.
@param HostBridgeInstance - PCI_HOST_BRIDGE_INSTANCE.
@retval EFI_SUCCESS - Function has completed successfully.
**/
EFI_STATUS
PciPlatformPostInit (
VOID
)
{
//
// Program all the IOAPIC in system
//
UINT8 Socket, Stack, IoApicId;
UINT8 Step;
UINT8 MaxSocket;
#if MAX_SOCKET <= 4
Step = 6;
MaxSocket = 4;
#else
Step = 4;
MaxSocket = 8;
#endif
Stack = 0;
IoApicId = 0;
ProgramIoApicId (mIioUds->IioUdsPtr->PlatformData.IIO_resource[0].StackRes[0].IoApicBase, PcdGet8(PcdIoApicId));
for (Socket = 0; Socket < MAX_SOCKET; Socket++) {
if (!(mIioUds->IioUdsPtr->SystemStatus.socketPresentBitMap & (1 << Socket)))
continue;
for (Stack = 0; Stack < MAX_IIO_STACK; Stack++) {
if (!(mIioUds->IioUdsPtr->PlatformData.CpuQpiInfo[Socket].stackPresentBitmap & (1 << Stack)))
continue;
if ((Socket < MaxSocket) && (Stack < Step)) {
IoApicId = PcdGet8(PcdPcIoApicIdBase) + Step * Socket + Stack;
}
if ((Socket == 0) && (Stack == 0)) {
ProgramIoApicId ((mIioUds->IioUdsPtr->PlatformData.IIO_resource[Socket].StackRes[Stack].IoApicBase + 0x1000), IoApicId);
} else {
ProgramIoApicId (mIioUds->IioUdsPtr->PlatformData.IIO_resource[Socket].StackRes[Stack].IoApicBase, IoApicId);
}
}
}
return EFI_SUCCESS;
}
/**
The PlatformPrepController() function can be used to notify the platform driver so that
it can perform platform-specific actions. No specific actions are required.
Several notification points are defined at this time. More synchronization points may be
added as required in the future. The PCI bus driver calls the platform driver twice for
every PCI controller-once before the PCI Host Bridge Resource Allocation Protocol driver
is notified, and once after the PCI Host Bridge Resource Allocation Protocol driver has
been notified.
This member function may not perform any error checking on the input parameters. It also
does not return any error codes. If this member function detects any error condition, it
needs to handle those errors on its own because there is no way to surface any errors to
the caller.
@param This - Pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
@param HostBridge - The associated PCI host bridge handle.
@param RootBridge - The associated PCI root bridge handle.
@param PciAddress - The address of the PCI device on the PCI bus.
@param Phase - The phase of the PCI controller enumeration.
@param ChipsetPhase - Defines the execution phase of the PCI chipset driver.
@retval EFI_SUCCESS - The function completed successfully.
@retval EFI_UNSUPPORTED - Not supported.
**/
EFI_STATUS
EFIAPI
PlatformPrepController (
IN EFI_PCI_PLATFORM_PROTOCOL *This,
IN EFI_HANDLE HostBridge,
IN EFI_HANDLE RootBridge,
IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS PciAddress,
IN EFI_PCI_CONTROLLER_RESOURCE_ALLOCATION_PHASE Phase,
IN EFI_PCI_CHIPSET_EXECUTION_PHASE ChipsetPhase
)
{
if (mPciPrivateData.RootBridgeHandle == NULL) {
mPciPrivateData.RootBridgeHandle = RootBridge;
}
return EFI_SUCCESS;
}
/**
Perform initialization by the phase indicated.
@param This - Pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
@param HostBridge - The associated PCI host bridge handle.
@param Phase - The phase of the PCI controller enumeration.
@param ChipsetPhase - Defines the execution phase of the PCI chipset driver.
@retval EFI_SUCCESS - Must return with success.
**/
EFI_STATUS
EFIAPI
PhaseNotify (
IN EFI_PCI_PLATFORM_PROTOCOL *This,
IN EFI_HANDLE HostBridge,
IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PHASE Phase,
IN EFI_PCI_CHIPSET_EXECUTION_PHASE ChipsetPhase
)
{
EFI_STATUS Status;
UINT8 i;
UINT8 Stack;
if (ChipsetPhase == ChipsetEntry) {
return EFI_SUCCESS;
}
//
// If for multiple host bridges, need special consideration
//
switch (Phase) {
case EfiPciHostBridgeBeginEnumeration:
//
// Pre-initialization before PCI bus enumeration
// No bus number and no PCI resource
//
Status = gBS->LocateProtocol (
&gEfiPciRootBridgeIoProtocolGuid,
NULL,
&(mPciPrivateData.PciRootBridgeIo)
);
ASSERT_EFI_ERROR (Status);
Status = gBS->LocateProtocol (
&gEfiCpuIo2ProtocolGuid,
NULL,
&(mPciPrivateData.CpuIo)
);
ASSERT_EFI_ERROR (Status);
mPciPrivateData.Context.CpuIo = mPciPrivateData.CpuIo;
DEBUG ((DEBUG_ERROR, "PCI Platform Pre-Initialization (Before bus scanning)\n"));
PciPlatformEarlyInit ();
break;
case EfiPciHostBridgeEndBusAllocation:
//
// There are two rounds PCI bus scanning
// First round will initilize the PCI hotplug device
// Second round will be the final one
//
if (mPciPrivateData.BusAssignedTime == 0) {
mPciPrivateData.PciEnumerationPhase = EfiPciEnumerationDeviceScanning;
for (i = 0 ; i < MaxIIO ; i++) {
if (mIioUds->IioUdsPtr->PlatformData.IIO_resource[i].Valid) {
for(Stack = 0; Stack < MAX_IIO_STACK; Stack ++) {
PciTreeTraverse (mIioUds->IioUdsPtr->PlatformData.CpuQpiInfo[i].StackBus[Stack]);
}
}
}
mPciPrivateData.BusAssignedTime++;
DEBUG ((DEBUG_ERROR, "PCI Platform bus assigned\n"));
}
break;
case EfiPciHostBridgeBeginResourceAllocation:
//
// PCI bus number has been assigned, but resource is still empty
//
DEBUG ((DEBUG_ERROR, "PCI Platform Mid-Initialization (After bus number assignment)\n"));
mPciPrivateData.PciEnumerationPhase = EfiPciEnumerationBusNumberAssigned;
for (i = 0 ; i < MaxIIO ; i++) {
if (mIioUds->IioUdsPtr->PlatformData.IIO_resource[i].Valid) {
for(Stack = 0; Stack < MAX_IIO_STACK; Stack ++) {
PciTreeTraverse (mIioUds->IioUdsPtr->PlatformData.CpuQpiInfo[i].StackBus[Stack]);
}
}
}
//PciPlatformMidInit ();
break;
case EfiPciHostBridgeEndResourceAllocation:
//
// Resource enumeration is done.
// Both bus number and resource have been assigned
// Do any post initialization.
//
DEBUG ((DEBUG_ERROR, "PCI Platform Post-Initialization (After resource alloction)\n"));
mPciPrivateData.PciEnumerationPhase = EfiPciEnumerationResourceAssigned;
for (i = 0 ; i < MaxIIO ; i++) {
if (mIioUds->IioUdsPtr->PlatformData.IIO_resource[i].Valid) {
for(Stack = 0; Stack < MAX_IIO_STACK; Stack ++) {
PciTreeTraverse (mIioUds->IioUdsPtr->PlatformData.CpuQpiInfo[i].StackBus[Stack]);
}
}
}
PciPlatformPostInit ();
break;
default:
return EFI_UNSUPPORTED;
}
return EFI_SUCCESS;
}
|