DriverSupport.c revision 4fd606d1f5abe38e1f42c38de1d2e895166bd0f4
/** @file
Support functions to connect/disconnect UEFI Driver model Protocol
Copyright (c) 2006 - 2011, 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
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 "DxeMain.h"
#include "Handle.h"
//
// Driver Support Functions
//
/**
Connects one or more drivers to a controller.
@param ControllerHandle Handle of the controller to be
connected.
@param DriverImageHandle DriverImageHandle A pointer to an
ordered list of driver image
handles.
@param RemainingDevicePath RemainingDevicePath A pointer to
the device path that specifies a
child of the controller specified
by ControllerHandle.
@param Recursive Whether the function would be
called recursively or not.
@return Status code.
**/
)
{
//
// Make sure ControllerHandle is valid
//
return Status;
}
//
// Make a copy of RemainingDevicePath to guanatee it is aligned
//
if (RemainingDevicePath != NULL) {
if (AlignedRemainingDevicePath == NULL) {
return EFI_OUT_OF_RESOURCES;
}
}
//
// Connect all drivers to ControllerHandle
// If CoreConnectSingleController returns EFI_NOT_READY, then the number of
// Driver Binding Protocols in the handle database has increased during the call
// so the connect operation must be restarted
//
do {
);
} while (ReturnStatus == EFI_NOT_READY);
//
// Free the aligned copy of RemainingDevicePath
//
if (AlignedRemainingDevicePath != NULL) {
}
//
// If recursive, then connect all drivers to all of ControllerHandle's children
//
if (Recursive) {
//
// Acquire the protocol lock on the handle database so the child handles can be collected
//
//
// Make sure the DriverBindingHandle is valid
//
//
// Release the protocol lock on the handle database
//
return ReturnStatus;
}
//
// Count ControllerHandle's children
//
for (Link = Handle->Protocols.ForwardLink, ChildHandleCount = 0; Link != &Handle->Protocols; Link = Link->ForwardLink) {
}
}
}
//
// Allocate a handle buffer for ControllerHandle's children
//
if (ChildHandleBuffer == NULL) {
return EFI_OUT_OF_RESOURCES;
}
//
// Fill in a handle buffer with ControllerHandle's children
//
for (Link = Handle->Protocols.ForwardLink, ChildHandleCount = 0; Link != &Handle->Protocols; Link = Link->ForwardLink) {
}
}
}
//
// Release the protocol lock on the handle database
//
//
// Recursively connect each child handle
//
NULL,
NULL,
);
}
//
// Free the handle buffer of ControllerHandle's children
//
}
return ReturnStatus;
}
/**
Add Driver Binding Protocols from Context Driver Image Handles to sorted
Driver Binding Protocol list.
@param DriverBindingHandle Handle of the driver binding
protocol.
@param NumberOfSortedDriverBindingProtocols Number Of sorted driver binding
protocols
@param SortedDriverBindingProtocols The sorted protocol list.
@param DriverBindingHandleCount Driver Binding Handle Count.
@param DriverBindingHandleBuffer The buffer of driver binding
protocol to be modified.
@param IsImageHandle Indicate whether
DriverBindingHandle is an image
handle
@return None.
**/
)
{
//
// Make sure the DriverBindingHandle is valid
//
return;
}
//
// If IsImageHandle is TRUE, then DriverBindingHandle is an image handle
// Find all the DriverBindingHandles associated with that image handle and add them to the sorted list
//
if (IsImageHandle) {
//
// Loop through all the Driver Binding Handles
//
//
// Retrieve the Driver Binding Protocol associated with each Driver Binding Handle
//
(VOID **) &DriverBinding
);
continue;
}
//
// If the ImageHandle associated with DriverBinding matches DriverBindingHandle,
// then add the DriverBindingProtocol[Index] to the sorted list
//
);
}
}
return;
}
//
// Retrieve the Driver Binding Protocol from DriverBindingHandle
//
(VOID **) &DriverBinding
);
//
// If DriverBindingHandle does not support the Driver Binding Protocol then return
//
return;
}
//
// See if DriverBinding is already in the sorted list
//
for (Index = 0; Index < *NumberOfSortedDriverBindingProtocols && Index < DriverBindingHandleCount; Index++) {
return;
}
}
//
// Add DriverBinding to the end of the list
//
}
//
// Mark the cooresponding handle in DriverBindingHandleBuffer as used
//
}
}
}
/**
Connects a controller to a driver.
@param ControllerHandle Handle of the controller to be
connected.
@param ContextDriverImageHandles DriverImageHandle A pointer to an
ordered list of driver image
handles.
@param RemainingDevicePath RemainingDevicePath A pointer to
the device path that specifies a
child of the controller
specified by ControllerHandle.
@retval EFI_SUCCESS One or more drivers were
connected to ControllerHandle.
@retval EFI_OUT_OF_RESOURCES No enough system resources to
complete the request.
@retval EFI_NOT_FOUND No drivers were connected to
ControllerHandle.
**/
)
{
//
// Initialize local variables
//
//
// Get list of all Driver Binding Protocol Instances
//
NULL,
);
return EFI_NOT_FOUND;
}
//
// Allocate a duplicate array for the sorted Driver Binding Protocol Instances
//
if (SortedDriverBindingProtocols == NULL) {
return EFI_OUT_OF_RESOURCES;
}
//
// Add Driver Binding Protocols from Context Driver Image Handles first
//
if (ContextDriverImageHandles != NULL) {
);
}
}
//
// Add the Platform Driver Override Protocol drivers for ControllerHandle next
//
NULL,
(VOID **) &PlatformDriverOverride
);
do {
);
);
}
}
//
// Add the Driver Family Override Protocol drivers for ControllerHandle
//
while (TRUE) {
HighestVersion = 0;
(VOID **) &DriverFamilyOverride
);
}
}
}
if (HighestIndex == DriverBindingHandleCount) {
break;
}
);
}
//
// Get the Bus Specific Driver Override Protocol instance on the Controller Handle
//
);
do {
);
);
}
}
//
// Then add all the remaining Driver Binding Protocols
//
);
}
//
// Free the Driver Binding Handle Buffer
//
//
// If the number of Driver Binding Protocols has increased since this function started, then return
// EFI_NOT_READY, so it will be restarted
//
NULL,
);
//
// Free any buffers that were allocated with AllocatePool()
//
return EFI_NOT_READY;
}
//
// Sort the remaining DriverBinding Protocol based on their Version field from
// highest to lowest.
//
}
}
if (SortIndex != HighestIndex) {
}
}
//
// Loop until no more drivers can be started on ControllerHandle
//
OneStarted = FALSE;
do {
//
// Loop through the sorted Driver Binding Protocol Instances in order, and see if
// any of the Driver Binding Protocols support the controller specified by
// ControllerHandle.
//
DriverFound = FALSE;
);
DriverFound = TRUE;
//
// A driver was found that supports ControllerHandle, so attempt to start the driver
// on ControllerHandle.
//
);
//
// The driver was successfully started on ControllerHandle, so set a flag
//
OneStarted = TRUE;
}
}
}
}
} while (DriverFound);
//
// Free any buffers that were allocated with AllocatePool()
//
//
// If at least one driver was started on ControllerHandle, then return EFI_SUCCESS.
//
if (OneStarted) {
return EFI_SUCCESS;
}
//
// If no drivers started and RemainingDevicePath is an End Device Path Node, then return EFI_SUCCESS
//
if (RemainingDevicePath != NULL) {
if (IsDevicePathEnd (RemainingDevicePath)) {
return EFI_SUCCESS;
}
}
//
// Otherwise, no drivers were started on ControllerHandle, so return EFI_NOT_FOUND
//
return EFI_NOT_FOUND;
}
/**
Disonnects a controller from a driver
@param ControllerHandle ControllerHandle The handle of
the controller from which
driver(s) are to be
disconnected.
@param DriverImageHandle DriverImageHandle The driver to
disconnect from ControllerHandle.
@param ChildHandle ChildHandle The handle of the
child to destroy.
@retval EFI_SUCCESS One or more drivers were
disconnected from the controller.
@retval EFI_SUCCESS On entry, no drivers are managing
ControllerHandle.
@retval EFI_SUCCESS DriverImageHandle is not NULL,
and on entry DriverImageHandle is
not managing ControllerHandle.
@retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
@retval EFI_INVALID_PARAMETER DriverImageHandle is not NULL,
and it is not a valid EFI_HANDLE.
@retval EFI_INVALID_PARAMETER ChildHandle is not NULL, and it
is not a valid EFI_HANDLE.
@retval EFI_OUT_OF_RESOURCES There are not enough resources
available to disconnect any
drivers from ControllerHandle.
@retval EFI_DEVICE_ERROR The controller could not be
disconnected because of a device
error.
**/
)
{
//
// Make sure ControllerHandle is valid
//
return Status;
}
//
// Make sure ChildHandle is valid if it is not NULL
//
if (ChildHandle != NULL) {
return Status;
}
}
//
// Get list of drivers that are currently managing ControllerHandle
//
if (DriverImageHandle == NULL) {
//
// Look at each protocol interface for a match
//
}
}
}
//
// If there are no drivers managing this controller, then return EFI_SUCCESS
//
if (DriverImageHandleCount == 0) {
goto Done;
}
if (DriverImageHandleBuffer == NULL) {
goto Done;
}
break;
}
}
if (!Duplicate) {
}
}
}
}
}
StopCount = 0;
if (DriverImageHandleBuffer != NULL) {
}
//
// Get the Driver Binding Protocol of the driver that is managing this controller
//
(VOID **)&DriverBinding
);
goto Done;
}
//
// Look at each protocol interface for a match
//
ChildBufferCount = 0;
}
}
}
}
}
if (DriverImageHandleValid) {
ChildBuffer = NULL;
if (ChildBufferCount != 0) {
if (ChildBuffer == NULL) {
goto Done;
}
ChildBufferCount = 0;
break;
}
}
if (!Duplicate) {
}
}
}
}
}
}
ChildrenToStop = 0;
if (ChildBufferCount > 0) {
if (ChildHandle != NULL) {
ChildrenToStop = 1;
} else {
}
}
}
StopCount++;
}
}
if (ChildBuffer != NULL) {
}
}
}
if (StopCount > 0) {
} else {
}
Done:
if (DriverImageHandleBuffer != NULL) {
}
return Status;
}