DriverDisconnection.c

Go to the documentation of this file.

 
#include <Uefi.h>
 
#include <IndustryStandard/Pci.h>
 
#include <Protocol/AudioDecode.h>
#include <Protocol/BlockIo.h>
#include <Protocol/HdaControllerInfo.h>
#include <Protocol/PciIo.h>
#include <Protocol/SimpleFileSystem.h>
 
#include <Library/DebugLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/OcDebugLogLib.h>
#include <Library/OcDeviceMiscLib.h>
#include <Library/OcDriverConnectionLib.h>
#include <Library/OcHdaDevicesLib.h>
#include <Library/UefiBootServicesTableLib.h>
 
EFI_STATUS
OcDisconnectDriversOnHandle (
  IN EFI_HANDLE  Controller
  )
{
  EFI_STATUS                           Status;
  UINTN                                NumBlockIoInfo;
  EFI_OPEN_PROTOCOL_INFORMATION_ENTRY  *BlockIoInfos;
  UINTN                                BlockIoInfoIndex;
 
  //
  // Disconnect any blocking drivers if applicable.
  //
  Status = gBS->OpenProtocolInformation (
                  Controller,
                  &gEfiBlockIoProtocolGuid,
                  &BlockIoInfos,
                  &NumBlockIoInfo
                  );
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_INFO, "OCDC: Attached drivers could not been retrieved\n"));
    return Status;
  }
 
  for (BlockIoInfoIndex = 0; BlockIoInfoIndex < NumBlockIoInfo; ++BlockIoInfoIndex) {
    if ((BlockIoInfos[BlockIoInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
      Status = gBS->DisconnectController (
                      Controller,
                      BlockIoInfos[BlockIoInfoIndex].AgentHandle,
                      NULL
                      );
      if (EFI_ERROR (Status)) {
        DEBUG ((
          DEBUG_INFO,
          "OCDC: Failed to unblock handle %p - %r\n",
          Controller,
          Status
          ));
      }
    }
  }
 
  FreePool (BlockIoInfos);
  return EFI_SUCCESS;
}
 
VOID
OcUnblockUnmountedPartitions (
  VOID
  )
{
  EFI_STATUS  Status;
 
  UINTN       NumHandles;
  EFI_HANDLE  *Handles;
  UINTN       HandleIndex;
 
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *FileSystem;
  EFI_BLOCK_IO_PROTOCOL            *BlockIo;
 
  //
  // For all Block I/O handles, check whether it is a partition. If it is and
  // does not have a File System protocol attached, ensure it does not have a
  // blocking driver attached which prevents the connection of a FS driver.
  //
  Status = gBS->LocateHandleBuffer (
                  ByProtocol,
                  &gEfiBlockIoProtocolGuid,
                  NULL,
                  &NumHandles,
                  &Handles
                  );
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_INFO, "OCDC: Could not locate DiskIo handles\n"));
    return;
  }
 
  for (HandleIndex = 0; HandleIndex < NumHandles; ++HandleIndex) {
    //
    // Skip the current handle if a File System driver is already attached.
    //
    Status = gBS->HandleProtocol (
                    Handles[HandleIndex],
                    &gEfiSimpleFileSystemProtocolGuid,
                    (VOID **)&FileSystem
                    );
    if (!EFI_ERROR (Status)) {
      continue;
    }
 
    //
    // Ensure the current handle describes a partition.
    //
    Status = gBS->HandleProtocol (
                    Handles[HandleIndex],
                    &gEfiBlockIoProtocolGuid,
                    (VOID **)&BlockIo
                    );
    if (EFI_ERROR (Status) || !BlockIo->Media->LogicalPartition) {
      continue;
    }
 
    OcDisconnectDriversOnHandle (Handles[HandleIndex]);
  }
 
  FreePool (Handles);
}
 
VOID
OcDisconnectGraphicsDrivers (
  VOID
  )
{
  EFI_STATUS  Status;
  UINT32      Index;
 
  UINTN                HandleCount;
  EFI_HANDLE           *HandleBuffer;
  EFI_PCI_IO_PROTOCOL  *PciIo;
  PCI_TYPE00           Pci;
 
  //
  // Locate all currently connected PCI I/O protocols and disconnect graphics drivers.
  //
  Status = gBS->LocateHandleBuffer (
                  ByProtocol,
                  &gEfiPciIoProtocolGuid,
                  NULL,
                  &HandleCount,
                  &HandleBuffer
                  );
  if (!EFI_ERROR (Status)) {
    DEBUG ((DEBUG_INFO, "OCDC: Found %u handles with PCI I/O\n", (UINT32)HandleCount));
    for (Index = 0; Index < HandleCount; Index++) {
      Status = gBS->HandleProtocol (
                      HandleBuffer[Index],
                      &gEfiPciIoProtocolGuid,
                      (VOID **)&PciIo
                      );
      if (EFI_ERROR (Status)) {
        continue;
      }
 
      Status = PciIo->Pci.Read (
                            PciIo,
                            EfiPciIoWidthUint32,
                            0,
                            sizeof (Pci) / sizeof (UINT32),
                            &Pci
                            );
      if (!EFI_ERROR (Status)) {
        if (IS_PCI_VGA (&Pci) == TRUE) {
          Status = gBS->DisconnectController (HandleBuffer[Index], NULL, NULL);
          DEBUG ((DEBUG_INFO, "OCDC: Disconnected graphics driver handle %u - %p result - %r\n", Index, HandleBuffer[Index], Status));
        }
      }
    }
 
    FreePool (HandleBuffer);
  }
}
 
VOID
OcDisconnectHdaControllers (
  VOID
  )
{
  EFI_STATUS  Status;
  UINT32      Index;
 
  UINTN                HandleCount;
  EFI_HANDLE           *HandleBuffer;
  EFI_PCI_IO_PROTOCOL  *PciIo;
  PCI_CLASSCODE        HdaClassReg;
 
  //
  // Locate all currently connected PCI I/O protocols and disconnect HDA controllers.
  //
  Status = gBS->LocateHandleBuffer (
                  ByProtocol,
                  &gEfiPciIoProtocolGuid,
                  NULL,
                  &HandleCount,
                  &HandleBuffer
                  );
  if (!EFI_ERROR (Status)) {
    DEBUG ((DEBUG_INFO, "OCDC: Found %u handles with PCI I/O\n", (UINT32)HandleCount));
    for (Index = 0; Index < HandleCount; Index++) {
      Status = gBS->HandleProtocol (
                      HandleBuffer[Index],
                      &gEfiPciIoProtocolGuid,
                      (VOID **)&PciIo
                      );
      if (EFI_ERROR (Status)) {
        continue;
      }
 
      //
      // Read class code from PCI.
      //
      Status = PciIo->Pci.Read (
                            PciIo,
                            EfiPciIoWidthUint8,
                            PCI_CLASSCODE_OFFSET,
                            sizeof (PCI_CLASSCODE),
                            &HdaClassReg
                            );
 
      //
      // Check class code, ignore everything but HDA controllers.
      //
      if (  EFI_ERROR (Status)
         || (HdaClassReg.BaseCode != PCI_CLASS_MEDIA)
         || (HdaClassReg.SubClassCode != PCI_CLASS_MEDIA_MIXED_MODE))
      {
        continue;
      }
 
      DebugPrintDevicePathForHandle (DEBUG_INFO, "OCDC: Disconnecting audio controller", HandleBuffer[Index]);
      Status = gBS->DisconnectController (HandleBuffer[Index], NULL, NULL);
      DEBUG ((DEBUG_INFO, "OCDC: Disconnected - %r\n", Status));
    }
 
    FreePool (HandleBuffer);
  }
}