SioService.c

Go to the documentation of this file.

 
#include "SioBusDxe.h"
 
//
// Super I/O Protocol interfaces
//
EFI_SIO_PROTOCOL  mSioInterface = {
  SioRegisterAccess,
  SioGetResources,
  SioSetResources,
  SioPossibleResources,
  SioModify
};
 
//
// COM 1 UART Controller
//
GLOBAL_REMOVE_IF_UNREFERENCED
SIO_RESOURCES_IO  mCom1Resources = {
  {
    { ACPI_FIXED_LOCATION_IO_PORT_DESCRIPTOR }, 0x3F8, 8
  },
  { ACPI_END_TAG_DESCRIPTOR, 0             }
};
 
//
// COM 2 UART Controller
//
GLOBAL_REMOVE_IF_UNREFERENCED
SIO_RESOURCES_IO  mCom2Resources = {
  {
    { ACPI_FIXED_LOCATION_IO_PORT_DESCRIPTOR }, 0x2F8, 8
  },
  { ACPI_END_TAG_DESCRIPTOR, 0             }
};
 
//
// PS/2 Keyboard Controller
//
GLOBAL_REMOVE_IF_UNREFERENCED
SIO_RESOURCES_IO  mPs2KeyboardDeviceResources = {
  {
    { ACPI_FIXED_LOCATION_IO_PORT_DESCRIPTOR }, 0x60, 5
  },
  { ACPI_END_TAG_DESCRIPTOR, 0             }
};
 
//
// Table of SIO Controllers
//
GLOBAL_REMOVE_IF_UNREFERENCED
SIO_DEVICE_INFO  mDevicesInfo[] = {
  {
    EISA_PNP_ID (0x501),
    0,
    { (ACPI_SMALL_RESOURCE_HEADER *)&mCom1Resources              }
  },  // COM 1 UART Controller
  {
    EISA_PNP_ID (0x501),
    1,
    { (ACPI_SMALL_RESOURCE_HEADER *)&mCom2Resources              }
  },  // COM 2 UART Controller
  {
    EISA_PNP_ID (0x303),
    0,
    { (ACPI_SMALL_RESOURCE_HEADER *)&mPs2KeyboardDeviceResources }
  }   // PS/2 Keyboard Controller
};
 
//
// ACPI Device Path Node template
//
GLOBAL_REMOVE_IF_UNREFERENCED
ACPI_HID_DEVICE_PATH  mAcpiDeviceNodeTemplate = {
  {        // Header
    ACPI_DEVICE_PATH,
    ACPI_DP,
    {
      (UINT8)(sizeof (ACPI_HID_DEVICE_PATH)),
      (UINT8)((sizeof (ACPI_HID_DEVICE_PATH)) >> 8)
    }
  },
  0x0,     // HID
  0x0      // UID
};
 
EFI_STATUS
EFIAPI
SioRegisterAccess (
  IN CONST EFI_SIO_PROTOCOL  *This,
  IN       BOOLEAN           Write,
  IN       BOOLEAN           ExitCfgMode,
  IN       UINT8             Register,
  IN OUT   UINT8             *Value
  )
{
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
SioGetResources (
  IN CONST EFI_SIO_PROTOCOL          *This,
  OUT      ACPI_RESOURCE_HEADER_PTR  *ResourceList
  )
{
  SIO_DEV  *SioDevice;
 
  if (ResourceList == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  SioDevice = SIO_DEV_FROM_SIO (This);
  if (SioDevice->DeviceIndex < ARRAY_SIZE (mDevicesInfo)) {
    *ResourceList = mDevicesInfo[SioDevice->DeviceIndex].Resources;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
SioSetResources (
  IN CONST EFI_SIO_PROTOCOL          *This,
  IN       ACPI_RESOURCE_HEADER_PTR  ResourceList
  )
{
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
SioPossibleResources (
  IN CONST EFI_SIO_PROTOCOL          *This,
  OUT      ACPI_RESOURCE_HEADER_PTR  *ResourceCollection
  )
{
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
SioModify (
  IN CONST EFI_SIO_PROTOCOL         *This,
  IN CONST EFI_SIO_REGISTER_MODIFY  *Command,
  IN       UINTN                    NumberOfCommands
  )
{
  return EFI_SUCCESS;
}
 
EFI_STATUS
SioCreateChildDevice (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN EFI_PCI_IO_PROTOCOL          *PciIo,
  IN EFI_DEVICE_PATH_PROTOCOL     *ParentDevicePath,
  IN UINT32                       DeviceIndex
  )
{
  EFI_STATUS  Status;
  SIO_DEV     *SioDevice;
 
  //
  // Initialize the SIO_DEV structure
  //
  SioDevice = AllocateZeroPool (sizeof (SIO_DEV));
  if (SioDevice == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  SioDevice->Signature = SIO_DEV_SIGNATURE;
  SioDevice->Handle    = NULL;
  SioDevice->PciIo     = PciIo;
 
  //
  // Construct the child device path
  //
  mAcpiDeviceNodeTemplate.HID = mDevicesInfo[DeviceIndex].Hid;
  mAcpiDeviceNodeTemplate.UID = mDevicesInfo[DeviceIndex].Uid;
  SioDevice->DevicePath       = AppendDevicePathNode (
                                  ParentDevicePath,
                                  (EFI_DEVICE_PATH_PROTOCOL *)&mAcpiDeviceNodeTemplate
                                  );
  if (SioDevice->DevicePath == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
  CopyMem (&SioDevice->Sio, &mSioInterface, sizeof (EFI_SIO_PROTOCOL));
  SioDevice->DeviceIndex = DeviceIndex;
 
  //
  // Create a child handle and install Device Path and Super I/O protocols
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &SioDevice->Handle,
                  &gEfiDevicePathProtocolGuid,
                  SioDevice->DevicePath,
                  &gEfiSioProtocolGuid,
                  &SioDevice->Sio,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    goto Done;
  }
 
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiPciIoProtocolGuid,
                  (VOID **)&PciIo,
                  This->DriverBindingHandle,
                  SioDevice->Handle,
                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
                  );
  if (EFI_ERROR (Status)) {
    gBS->UninstallMultipleProtocolInterfaces (
           SioDevice->Handle,
           &gEfiDevicePathProtocolGuid,
           SioDevice->DevicePath,
           &gEfiSioProtocolGuid,
           &SioDevice->Sio,
           NULL
           );
  }
 
Done:
  if (EFI_ERROR (Status)) {
    if (SioDevice->DevicePath != NULL) {
      FreePool (SioDevice->DevicePath);
    }
 
    FreePool (SioDevice);
  }
 
  return Status;
}
 
UINT32
SioCreateAllChildDevices (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN EFI_PCI_IO_PROTOCOL          *PciIo,
  IN EFI_DEVICE_PATH_PROTOCOL     *ParentDevicePath
  )
{
  UINT32      Index;
  UINT32      ChildDeviceNumber;
  EFI_STATUS  Status;
 
  ChildDeviceNumber = 0;
 
  for (Index = 0; Index < ARRAY_SIZE (mDevicesInfo); Index++) {
    Status = SioCreateChildDevice (
               This,
               Controller,
               PciIo,
               ParentDevicePath,
               Index
               );
    if (!EFI_ERROR (Status)) {
      ChildDeviceNumber++;
    }
  }
 
  return ChildDeviceNumber;
}