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
|
/** @file
Functions implementation for Bus Specific Driver Override protocol.
Copyright (c) 2006 - 2019, 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
which 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 "PciBus.h"
/**
Initializes a PCI Driver Override Instance.
@param PciIoDevice PCI Device instance.
**/
VOID
InitializePciDriverOverrideInstance (
IN OUT PCI_IO_DEVICE *PciIoDevice
)
{
PciIoDevice->PciDriverOverride.GetDriver = GetDriver;
}
/**
Find the image handle whose path equals to ImagePath.
@param ImagePath Image path.
@return Image handle.
**/
EFI_HANDLE
LocateImageHandle (
IN EFI_DEVICE_PATH_PROTOCOL *ImagePath
)
{
EFI_STATUS Status;
EFI_HANDLE *Handles;
UINTN Index;
UINTN HandleNum;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
UINTN ImagePathSize;
EFI_HANDLE ImageHandle;
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiLoadedImageDevicePathProtocolGuid,
NULL,
&HandleNum,
&Handles
);
if (EFI_ERROR (Status)) {
return NULL;
}
ImageHandle = NULL;
ImagePathSize = GetDevicePathSize (ImagePath);
for (Index = 0; Index < HandleNum; Index++) {
Status = gBS->HandleProtocol (Handles[Index], &gEfiLoadedImageDevicePathProtocolGuid, (VOID **) &DevicePath);
if (EFI_ERROR (Status)) {
continue;
}
if ((ImagePathSize == GetDevicePathSize (DevicePath)) &&
(CompareMem (ImagePath, DevicePath, ImagePathSize) == 0)
) {
ImageHandle = Handles[Index];
break;
}
}
FreePool (Handles);
return ImageHandle;
}
/**
Uses a bus specific algorithm to retrieve a driver image handle for a controller.
@param This A pointer to the EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL instance.
@param DriverImageHandle On input, a pointer to the previous driver image handle returned
by GetDriver(). On output, a pointer to the next driver
image handle. Passing in a NULL, will return the first driver
image handle.
@retval EFI_SUCCESS A bus specific override driver is returned in DriverImageHandle.
@retval EFI_NOT_FOUND The end of the list of override drivers was reached.
A bus specific override driver is not returned in DriverImageHandle.
@retval EFI_INVALID_PARAMETER DriverImageHandle is not a handle that was returned on a
previous call to GetDriver().
**/
EFI_STATUS
EFIAPI
GetDriver (
IN EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *This,
IN OUT EFI_HANDLE *DriverImageHandle
)
{
PCI_IO_DEVICE *PciIoDevice;
LIST_ENTRY *Link;
PCI_DRIVER_OVERRIDE_LIST *Override;
BOOLEAN ReturnNext;
Override = NULL;
PciIoDevice = PCI_IO_DEVICE_FROM_PCI_DRIVER_OVERRIDE_THIS (This);
ReturnNext = (BOOLEAN) (*DriverImageHandle == NULL);
for ( Link = GetFirstNode (&PciIoDevice->OptionRomDriverList)
; !IsNull (&PciIoDevice->OptionRomDriverList, Link)
; Link = GetNextNode (&PciIoDevice->OptionRomDriverList, Link)
) {
Override = DRIVER_OVERRIDE_FROM_LINK (Link);
if (ReturnNext) {
if (Override->DriverImageHandle == NULL) {
Override->DriverImageHandle = LocateImageHandle (Override->DriverImagePath);
}
if (Override->DriverImageHandle == NULL) {
//
// The Option ROM identified by Override->DriverImagePath is not loaded.
//
continue;
} else {
*DriverImageHandle = Override->DriverImageHandle;
return EFI_SUCCESS;
}
}
if (*DriverImageHandle == Override->DriverImageHandle) {
ReturnNext = TRUE;
}
}
ASSERT (IsNull (&PciIoDevice->OptionRomDriverList, Link));
//
// ReturnNext indicates a handle match happens.
// If all nodes are checked without handle match happening,
// the DriverImageHandle should be a invalid handle.
//
if (ReturnNext) {
return EFI_NOT_FOUND;
} else {
return EFI_INVALID_PARAMETER;
}
}
/**
Add an overriding driver image.
@param PciIoDevice Instance of PciIo device.
@param DriverImageHandle Image handle of newly added driver image.
@param DriverImagePath Device path of newly added driver image.
@retval EFI_SUCCESS Successfully added driver.
@retval EFI_OUT_OF_RESOURCES No memory resource for new driver instance.
@retval other Some error occurred when locating gEfiLoadedImageProtocolGuid.
**/
EFI_STATUS
AddDriver (
IN PCI_IO_DEVICE *PciIoDevice,
IN EFI_HANDLE DriverImageHandle,
IN EFI_DEVICE_PATH_PROTOCOL *DriverImagePath
)
{
PCI_DRIVER_OVERRIDE_LIST *Node;
//
// Caller should pass in either Image Handle or Image Path, but not both.
//
ASSERT ((DriverImageHandle == NULL) || (DriverImagePath == NULL));
Node = AllocateZeroPool (sizeof (PCI_DRIVER_OVERRIDE_LIST));
if (Node == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Node->Signature = DRIVER_OVERRIDE_SIGNATURE;
Node->DriverImageHandle = DriverImageHandle;
Node->DriverImagePath = DuplicateDevicePath (DriverImagePath);
InsertTailList (&PciIoDevice->OptionRomDriverList, &Node->Link);
PciIoDevice->BusOverride = TRUE;
return EFI_SUCCESS;
}
|
