From 878ddf1fc3540a715f63594ed22b6929e881afb4 Mon Sep 17 00:00:00 2001 From: bbahnsen Date: Fri, 21 Apr 2006 22:54:32 +0000 Subject: Initial import. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3 6f19259b-4bc3-4df7-8a09-765794883524 --- .../Debugger/Debugport/Dxe/ComponentName.c | 108 +++ .../Universal/Debugger/Debugport/Dxe/DebugPort.c | 833 +++++++++++++++++++++ .../Universal/Debugger/Debugport/Dxe/DebugPort.dxs | 26 + .../Universal/Debugger/Debugport/Dxe/DebugPort.h | 172 +++++ .../Universal/Debugger/Debugport/Dxe/DebugPort.mbd | 46 ++ .../Universal/Debugger/Debugport/Dxe/DebugPort.msa | 77 ++ .../Universal/Debugger/Debugport/Dxe/build.xml | 47 ++ 7 files changed, 1309 insertions(+) create mode 100644 EdkModulePkg/Universal/Debugger/Debugport/Dxe/ComponentName.c create mode 100644 EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.c create mode 100644 EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.dxs create mode 100644 EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.h create mode 100644 EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.mbd create mode 100644 EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.msa create mode 100644 EdkModulePkg/Universal/Debugger/Debugport/Dxe/build.xml (limited to 'EdkModulePkg/Universal/Debugger') diff --git a/EdkModulePkg/Universal/Debugger/Debugport/Dxe/ComponentName.c b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/ComponentName.c new file mode 100644 index 0000000..078bdab --- /dev/null +++ b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/ComponentName.c @@ -0,0 +1,108 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + ComponentName.c + +Abstract: + Component name protocol member functions for DebugPort... + +--*/ + +#include "DebugPort.h" + +// +// EFI Component Name Protocol +// +EFI_COMPONENT_NAME_PROTOCOL gDebugPortComponentName = { + DebugPortComponentNameGetDriverName, + DebugPortComponentNameGetControllerName, + "eng" +}; + +static EFI_UNICODE_STRING_TABLE mDebugPortDriverNameTable[] = { + { + "eng", + (CHAR16 *) L"DebugPort Driver" + }, + { + NULL, + NULL + } +}; + +EFI_STATUS +EFIAPI +DebugPortComponentNameGetDriverName ( + IN EFI_COMPONENT_NAME_PROTOCOL *This, + IN CHAR8 *Language, + OUT CHAR16 **DriverName + ) +/*++ + + Routine Description: + Retrieves a Unicode string that is the user readable name of the EFI Driver. + + Arguments: + This - A pointer to the EFI_COMPONENT_NAME_PROTOCOL instance. + Language - A pointer to a three character ISO 639-2 language identifier. + This is the language of the driver name that that the caller + is requesting, and it must match one of the languages specified + in SupportedLanguages. The number of languages supported by a + driver is up to the driver writer. + DriverName - A pointer to the Unicode string to return. This Unicode string + is the name of the driver specified by This in the language + specified by Language. + + Returns: + EFI_SUCCESS - The Unicode string for the Driver specified by This + and the language specified by Language was returned + in DriverName. + EFI_INVALID_PARAMETER - Language is NULL. + EFI_INVALID_PARAMETER - DriverName is NULL. + EFI_UNSUPPORTED - The driver specified by This does not support the + language specified by Language. + +--*/ +{ + return LookupUnicodeString ( + Language, + gDebugPortComponentName.SupportedLanguages, + mDebugPortDriverNameTable, + DriverName + ); +} + +EFI_STATUS +EFIAPI +DebugPortComponentNameGetControllerName ( + IN EFI_COMPONENT_NAME_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL, + IN CHAR8 *Language, + OUT CHAR16 **ControllerName + ) +/*++ + + Routine Description: + The debug port driver does not support GetControllerName, so this function + is just stubbed and returns EFI_UNSUPPORTED. + + Arguments: + Per EFI 1.10 driver model + + Returns: + EFI_UNSUPPORTED + +--*/ +{ + return EFI_UNSUPPORTED; +} diff --git a/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.c b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.c new file mode 100644 index 0000000..a24bfd0 --- /dev/null +++ b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.c @@ -0,0 +1,833 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + DebugPort.c + +Abstract: + + Top level C file for debugport driver. Contains initialization function. + This driver layers on top of SerialIo. + + ALL CODE IN THE SERIALIO STACK MUST BE RE-ENTRANT AND CALLABLE FROM + INTERRUPT CONTEXT. + +Revision History + +--*/ + + +#include "DebugPort.h" + +// +// Misc. functions local to this module +// +STATIC +VOID +GetDebugPortVariable ( + DEBUGPORT_DEVICE *DebugPortDevice + ); + +EFI_STATUS +EFIAPI +ImageUnloadHandler ( + EFI_HANDLE ImageHandle + ); + +// +// Globals +// + +EFI_DRIVER_BINDING_PROTOCOL gDebugPortDriverBinding = { + DebugPortSupported, + DebugPortStart, + DebugPortStop, + DEBUGPORT_DRIVER_VERSION, + NULL, + NULL +}; + +DEBUGPORT_DEVICE *gDebugPortDevice; +static UINT32 mHid16550; +static UINT32 mHidStdPcComPort; + +// +// implementation code +// + +EFI_STATUS +EFIAPI +InitializeDebugPortDriver ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/*++ + +Routine Description: + Driver entry point. Reads DebugPort variable to determine what device and settings + to use as the debug port. Binds exclusively to SerialIo. Reverts to defaults \ + if no variable is found. + + Creates debugport and devicepath protocols on new handle. + +Arguments: + ImageHandle, + SystemTable + +Returns: + + EFI_UNSUPPORTED + EFI_OUT_OF_RESOURCES + +--*/ +{ + mHid16550 = EFI_ACPI_16550UART_HID; + mHidStdPcComPort = EFI_ACPI_PC_COMPORT_HID; + + // + // Allocate and Initialize dev structure + // + gDebugPortDevice = AllocateZeroPool (sizeof (DEBUGPORT_DEVICE)); + if (gDebugPortDevice == NULL) { + return EFI_OUT_OF_RESOURCES; + } + // + // Fill in static and default pieces of device structure first. + // + gDebugPortDevice->Signature = DEBUGPORT_DEVICE_SIGNATURE; + + gDebugPortDevice->DebugPortInterface.Reset = DebugPortReset; + gDebugPortDevice->DebugPortInterface.Read = DebugPortRead; + gDebugPortDevice->DebugPortInterface.Write = DebugPortWrite; + gDebugPortDevice->DebugPortInterface.Poll = DebugPortPoll; + + gDebugPortDevice->BaudRate = DEBUGPORT_UART_DEFAULT_BAUDRATE; + gDebugPortDevice->ReceiveFifoDepth = DEBUGPORT_UART_DEFAULT_FIFO_DEPTH; + gDebugPortDevice->Timeout = DEBUGPORT_UART_DEFAULT_TIMEOUT; + gDebugPortDevice->Parity = DEBUGPORT_UART_DEFAULT_PARITY; + gDebugPortDevice->DataBits = DEBUGPORT_UART_DEFAULT_DATA_BITS; + gDebugPortDevice->StopBits = DEBUGPORT_UART_DEFAULT_STOP_BITS; + + return EFI_SUCCESS; +} +// +// DebugPort driver binding member functions... +// +EFI_STATUS +EFIAPI +DebugPortSupported ( + IN EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath + ) +/*++ + +Routine Description: + Checks to see that there's not already a DebugPort interface somewhere. If so, + fail. + + If there's a DEBUGPORT variable, the device path must match exactly. If there's + no DEBUGPORT variable, then device path is not checked and does not matter. + + Checks to see that there's a serial io interface on the controller handle + that can be bound BY_DRIVER | EXCLUSIVE. + + If all these tests succeed, then we return EFI_SUCCESS, else, EFI_UNSUPPORTED + or other error returned by OpenProtocol. + +Arguments: + This + ControllerHandle + RemainingDevicePath + +Returns: + EFI_UNSUPPORTED + EFI_OUT_OF_RESOURCES + EFI_SUCCESS + +--*/ +{ + EFI_STATUS Status; + EFI_DEVICE_PATH_PROTOCOL *Dp1; + EFI_DEVICE_PATH_PROTOCOL *Dp2; + EFI_SERIAL_IO_PROTOCOL *SerialIo; + EFI_DEBUGPORT_PROTOCOL *DebugPortInterface; + EFI_HANDLE TempHandle; + + // + // Check to see that there's not a debugport protocol already published + // + if (gBS->LocateProtocol (&gEfiDebugPortProtocolGuid, NULL, (VOID **) &DebugPortInterface) != EFI_NOT_FOUND) { + return EFI_UNSUPPORTED; + } + // + // Read DebugPort variable to determine debug port selection and parameters + // + GetDebugPortVariable (gDebugPortDevice); + + if (gDebugPortDevice->DebugPortVariable != NULL) { + // + // There's a DEBUGPORT variable, so do LocateDevicePath and check to see if + // the closest matching handle matches the controller handle, and if it does, + // check to see that the remaining device path has the DebugPort GUIDed messaging + // device path only. Otherwise, it's a mismatch and EFI_UNSUPPORTED is returned. + // + Dp1 = DuplicateDevicePath ((EFI_DEVICE_PATH_PROTOCOL *) gDebugPortDevice->DebugPortVariable); + if (Dp1 == NULL) { + return EFI_OUT_OF_RESOURCES; + } + + Dp2 = Dp1; + + Status = gBS->LocateDevicePath ( + &gEfiSerialIoProtocolGuid, + &Dp2, + &TempHandle + ); + + if (Status == EFI_SUCCESS && TempHandle != ControllerHandle) { + Status = EFI_UNSUPPORTED; + } + + if (Status == EFI_SUCCESS && (Dp2->Type != 3 || Dp2->SubType != 10 || *((UINT16 *) Dp2->Length) != 20)) { + Status = EFI_UNSUPPORTED; + } + + if (Status == EFI_SUCCESS && CompareMem (&gEfiDebugPortDevicePathGuid, Dp2 + 1, sizeof (EFI_GUID))) { + Status = EFI_UNSUPPORTED; + } + + gBS->FreePool (Dp1); + if (EFI_ERROR (Status)) { + return Status; + } + } + + Status = gBS->OpenProtocol ( + ControllerHandle, + &gEfiSerialIoProtocolGuid, + (VOID **) &SerialIo, + This->DriverBindingHandle, + ControllerHandle, + EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE + ); + if (EFI_ERROR (Status)) { + return Status; + } + + gBS->CloseProtocol ( + ControllerHandle, + &gEfiSerialIoProtocolGuid, + This->DriverBindingHandle, + ControllerHandle + ); + + return EFI_SUCCESS; +} + +EFI_STATUS +EFIAPI +DebugPortStart ( + IN EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath + ) +/*++ + +Routine Description: + Binds exclusively to serial io on the controller handle. Produces DebugPort + protocol and DevicePath on new handle. + +Arguments: + This + ControllerHandle + RemainingDevicePath + +Returns: + EFI_OUT_OF_RESOURCES + EFI_SUCCESS +--*/ +{ + EFI_STATUS Status; + DEBUGPORT_DEVICE_PATH DebugPortDP; + EFI_DEVICE_PATH_PROTOCOL EndDP; + EFI_DEVICE_PATH_PROTOCOL *Dp1; + + Status = gBS->OpenProtocol ( + ControllerHandle, + &gEfiSerialIoProtocolGuid, + (VOID **) &gDebugPortDevice->SerialIoBinding, + This->DriverBindingHandle, + ControllerHandle, + EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE + ); + if (EFI_ERROR (Status)) { + return Status; + } + + gDebugPortDevice->SerialIoDeviceHandle = ControllerHandle; + + // + // Initialize the Serial Io interface... + // + Status = gDebugPortDevice->SerialIoBinding->SetAttributes ( + gDebugPortDevice->SerialIoBinding, + gDebugPortDevice->BaudRate, + gDebugPortDevice->ReceiveFifoDepth, + gDebugPortDevice->Timeout, + gDebugPortDevice->Parity, + gDebugPortDevice->DataBits, + gDebugPortDevice->StopBits + ); + if (EFI_ERROR (Status)) { + gDebugPortDevice->BaudRate = 0; + gDebugPortDevice->Parity = DefaultParity; + gDebugPortDevice->DataBits = 0; + gDebugPortDevice->StopBits = DefaultStopBits; + gDebugPortDevice->ReceiveFifoDepth = 0; + Status = gDebugPortDevice->SerialIoBinding->SetAttributes ( + gDebugPortDevice->SerialIoBinding, + gDebugPortDevice->BaudRate, + gDebugPortDevice->ReceiveFifoDepth, + gDebugPortDevice->Timeout, + gDebugPortDevice->Parity, + gDebugPortDevice->DataBits, + gDebugPortDevice->StopBits + ); + if (EFI_ERROR (Status)) { + gBS->CloseProtocol ( + ControllerHandle, + &gEfiSerialIoProtocolGuid, + This->DriverBindingHandle, + ControllerHandle + ); + return Status; + } + } + + gDebugPortDevice->SerialIoBinding->Reset (gDebugPortDevice->SerialIoBinding); + + // + // Create device path instance for DebugPort + // + DebugPortDP.Header.Type = MESSAGING_DEVICE_PATH; + DebugPortDP.Header.SubType = MSG_VENDOR_DP; + SetDevicePathNodeLength (&(DebugPortDP.Header), sizeof (DebugPortDP)); + gBS->CopyMem (&DebugPortDP.Guid, &gEfiDebugPortDevicePathGuid, sizeof (EFI_GUID)); + + Dp1 = DevicePathFromHandle (ControllerHandle); + if (Dp1 == NULL) { + Dp1 = &EndDP; + SetDevicePathEndNode (Dp1); + } + + gDebugPortDevice->DebugPortDevicePath = AppendDevicePathNode (Dp1, (EFI_DEVICE_PATH_PROTOCOL *) &DebugPortDP); + if (gDebugPortDevice->DebugPortDevicePath == NULL) { + return EFI_OUT_OF_RESOURCES; + } + // + // Publish DebugPort and Device Path protocols + // + Status = gBS->InstallMultipleProtocolInterfaces ( + &gDebugPortDevice->DebugPortDeviceHandle, + &gEfiDevicePathProtocolGuid, + gDebugPortDevice->DebugPortDevicePath, + &gEfiDebugPortProtocolGuid, + &gDebugPortDevice->DebugPortInterface, + NULL + ); + + if (EFI_ERROR (Status)) { + gBS->CloseProtocol ( + ControllerHandle, + &gEfiSerialIoProtocolGuid, + This->DriverBindingHandle, + ControllerHandle + ); + return Status; + } + // + // Connect debugport child to serial io + // + Status = gBS->OpenProtocol ( + ControllerHandle, + &gEfiSerialIoProtocolGuid, + (VOID **) &gDebugPortDevice->SerialIoBinding, + This->DriverBindingHandle, + gDebugPortDevice->DebugPortDeviceHandle, + EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER + ); + + if (EFI_ERROR (Status)) { + DEBUG_CODE ( + UINTN BufferSize; + + BufferSize = 48; + DebugPortWrite ( + &gDebugPortDevice->DebugPortInterface, + 0, + &BufferSize, + "DebugPort driver failed to open child controller\n\n" + ); + ); + + gBS->CloseProtocol ( + ControllerHandle, + &gEfiSerialIoProtocolGuid, + This->DriverBindingHandle, + ControllerHandle + ); + return Status; + } + + DEBUG_CODE ( + UINTN BufferSize; + + BufferSize = 38; + DebugPortWrite ( + &gDebugPortDevice->DebugPortInterface, + 0, + &BufferSize, + "Hello World from the DebugPort driver\n\n" + ); + ); + + return EFI_SUCCESS; +} + +EFI_STATUS +EFIAPI +DebugPortStop ( + IN EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN UINTN NumberOfChildren, + IN EFI_HANDLE *ChildHandleBuffer + ) +/*++ + +Routine Description: + We're never intending to be stopped via the driver model so this just returns + EFI_UNSUPPORTED + +Arguments: + Per EFI 1.10 driver model + +Returns: + EFI_UNSUPPORTED + EFI_SUCCESS + +--*/ +{ + EFI_STATUS Status; + + if (NumberOfChildren == 0) { + // + // Close the bus driver + // + gBS->CloseProtocol ( + ControllerHandle, + &gEfiSerialIoProtocolGuid, + This->DriverBindingHandle, + ControllerHandle + ); + + gDebugPortDevice->SerialIoBinding = NULL; + + gBS->CloseProtocol ( + ControllerHandle, + &gEfiDevicePathProtocolGuid, + This->DriverBindingHandle, + ControllerHandle + ); + + gBS->FreePool (gDebugPortDevice->DebugPortDevicePath); + + return EFI_SUCCESS; + } else { + // + // Disconnect SerialIo child handle + // + Status = gBS->CloseProtocol ( + gDebugPortDevice->SerialIoDeviceHandle, + &gEfiSerialIoProtocolGuid, + This->DriverBindingHandle, + gDebugPortDevice->DebugPortDeviceHandle + ); + + if (EFI_ERROR (Status)) { + return Status; + } + // + // Unpublish our protocols (DevicePath, DebugPort) + // + Status = gBS->UninstallMultipleProtocolInterfaces ( + gDebugPortDevice->DebugPortDeviceHandle, + &gEfiDevicePathProtocolGuid, + gDebugPortDevice->DebugPortDevicePath, + &gEfiDebugPortProtocolGuid, + &gDebugPortDevice->DebugPortInterface, + NULL + ); + + if (EFI_ERROR (Status)) { + gBS->OpenProtocol ( + ControllerHandle, + &gEfiSerialIoProtocolGuid, + (VOID **) &gDebugPortDevice->SerialIoBinding, + This->DriverBindingHandle, + gDebugPortDevice->DebugPortDeviceHandle, + EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER + ); + } else { + gDebugPortDevice->DebugPortDeviceHandle = NULL; + } + } + + return Status; +} +// +// Debugport protocol member functions +// +EFI_STATUS +EFIAPI +DebugPortReset ( + IN EFI_DEBUGPORT_PROTOCOL *This + ) +/*++ + +Routine Description: + DebugPort protocol member function. Calls SerialIo:GetControl to flush buffer. + We cannot call SerialIo:SetAttributes because it uses pool services, which use + locks, which affect TPL, so it's not interrupt context safe or re-entrant. + SerialIo:Reset() calls SetAttributes, so it can't be used either. + + The port itself should be fine since it was set up during initialization. + +Arguments: + This + +Returns: + + EFI_SUCCESS + +--*/ +{ + DEBUGPORT_DEVICE *DebugPortDevice; + UINTN BufferSize; + UINTN BitBucket; + + DebugPortDevice = DEBUGPORT_DEVICE_FROM_THIS (This); + while (This->Poll (This) == EFI_SUCCESS) { + BufferSize = 1; + This->Read (This, 0, &BufferSize, &BitBucket); + } + + return EFI_SUCCESS; +} + +EFI_STATUS +EFIAPI +DebugPortRead ( + IN EFI_DEBUGPORT_PROTOCOL *This, + IN UINT32 Timeout, + IN OUT UINTN *BufferSize, + IN VOID *Buffer + ) +/*++ + +Routine Description: + DebugPort protocol member function. Calls SerialIo:Read() after setting + if it's different than the last SerialIo access. + +Arguments: + IN EFI_DEBUGPORT_PROTOCOL *This + IN UINT32 Timeout, + IN OUT UINTN *BufferSize, + IN VOID *Buffer + +Returns: + + EFI_STATUS + +--*/ +{ + DEBUGPORT_DEVICE *DebugPortDevice; + UINTN LocalBufferSize; + EFI_STATUS Status; + UINT8 *BufferPtr; + + DebugPortDevice = DEBUGPORT_DEVICE_FROM_THIS (This); + BufferPtr = Buffer; + LocalBufferSize = *BufferSize; + do { + Status = DebugPortDevice->SerialIoBinding->Read ( + DebugPortDevice->SerialIoBinding, + &LocalBufferSize, + BufferPtr + ); + if (Status == EFI_TIMEOUT) { + if (Timeout > DEBUGPORT_UART_DEFAULT_TIMEOUT) { + Timeout -= DEBUGPORT_UART_DEFAULT_TIMEOUT; + } else { + Timeout = 0; + } + } else if (EFI_ERROR (Status)) { + break; + } + + BufferPtr += LocalBufferSize; + LocalBufferSize = *BufferSize - (BufferPtr - (UINT8 *) Buffer); + } while (LocalBufferSize != 0 && Timeout > 0); + + *BufferSize = (UINTN) (BufferPtr - (UINT8 *) Buffer); + + return Status; +} + +EFI_STATUS +EFIAPI +DebugPortWrite ( + IN EFI_DEBUGPORT_PROTOCOL *This, + IN UINT32 Timeout, + IN OUT UINTN *BufferSize, + OUT VOID *Buffer + ) +/*++ + +Routine Description: + DebugPort protocol member function. Calls SerialIo:Write() Writes 8 bytes at + a time and does a GetControl between 8 byte writes to help insure reads are + interspersed This is poor-man's flow control.. + +Arguments: + This - Pointer to DebugPort protocol + Timeout - Timeout value + BufferSize - On input, the size of Buffer. + On output, the amount of data actually written. + Buffer - Pointer to buffer to write + +Returns: + EFI_SUCCESS - The data was written. + EFI_DEVICE_ERROR - The device reported an error. + EFI_TIMEOUT - The data write was stopped due to a timeout. + +--*/ +{ + DEBUGPORT_DEVICE *DebugPortDevice; + UINTN Position; + UINTN WriteSize; + EFI_STATUS Status; + UINT32 SerialControl; + + Status = EFI_SUCCESS; + DebugPortDevice = DEBUGPORT_DEVICE_FROM_THIS (This); + + WriteSize = 8; + for (Position = 0; Position < *BufferSize && !EFI_ERROR (Status); Position += WriteSize) { + DebugPortDevice->SerialIoBinding->GetControl ( + DebugPortDevice->SerialIoBinding, + &SerialControl + ); + if (*BufferSize - Position < 8) { + WriteSize = *BufferSize - Position; + } + + Status = DebugPortDevice->SerialIoBinding->Write ( + DebugPortDevice->SerialIoBinding, + &WriteSize, + &((UINT8 *) Buffer)[Position] + ); + } + + *BufferSize = Position; + return Status; +} + +EFI_STATUS +EFIAPI +DebugPortPoll ( + IN EFI_DEBUGPORT_PROTOCOL *This + ) +/*++ + +Routine Description: + DebugPort protocol member function. Calls SerialIo:Write() after setting + if it's different than the last SerialIo access. + +Arguments: + IN EFI_DEBUGPORT_PROTOCOL *This + +Returns: + EFI_SUCCESS - At least 1 character is ready to be read from the DebugPort interface + EFI_NOT_READY - There are no characters ready to read from the DebugPort interface + EFI_DEVICE_ERROR - A hardware failure occured... (from SerialIo) + +--*/ +{ + EFI_STATUS Status; + UINT32 SerialControl; + DEBUGPORT_DEVICE *DebugPortDevice; + + DebugPortDevice = DEBUGPORT_DEVICE_FROM_THIS (This); + + Status = DebugPortDevice->SerialIoBinding->GetControl ( + DebugPortDevice->SerialIoBinding, + &SerialControl + ); + + if (!EFI_ERROR (Status)) { + if (SerialControl & EFI_SERIAL_INPUT_BUFFER_EMPTY) { + Status = EFI_NOT_READY; + } else { + Status = EFI_SUCCESS; + } + } + + return Status; +} +// +// Misc. functions local to this module.. +// +STATIC +VOID +GetDebugPortVariable ( + DEBUGPORT_DEVICE *DebugPortDevice + ) +/*++ + +Routine Description: + Local worker function to obtain device path information from DebugPort variable. + Records requested settings in DebugPort device structure. + +Arguments: + DEBUGPORT_DEVICE *DebugPortDevice, + +Returns: + + Nothing + +--*/ +{ + UINTN DataSize; + EFI_DEVICE_PATH_PROTOCOL *DevicePath; + EFI_STATUS Status; + + DataSize = 0; + + Status = gRT->GetVariable ( + (CHAR16 *) EFI_DEBUGPORT_VARIABLE_NAME, + &gEfiDebugPortVariableGuid, + NULL, + &DataSize, + DebugPortDevice->DebugPortVariable + ); + + if (Status == EFI_BUFFER_TOO_SMALL) { + if (gDebugPortDevice->DebugPortVariable != NULL) { + gBS->FreePool (gDebugPortDevice->DebugPortVariable); + } + + DebugPortDevice->DebugPortVariable = AllocatePool (DataSize); + if (DebugPortDevice->DebugPortVariable != NULL) { + gRT->GetVariable ( + (CHAR16 *) EFI_DEBUGPORT_VARIABLE_NAME, + &gEfiDebugPortVariableGuid, + NULL, + &DataSize, + DebugPortDevice->DebugPortVariable + ); + DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) DebugPortDevice->DebugPortVariable; + while (!EfiIsDevicePathEnd (DevicePath) && !EfiIsUartDevicePath (DevicePath)) { + DevicePath = EfiNextDevicePathNode (DevicePath); + } + + if (EfiIsDevicePathEnd (DevicePath)) { + gBS->FreePool (gDebugPortDevice->DebugPortVariable); + DebugPortDevice->DebugPortVariable = NULL; + } else { + gBS->CopyMem ( + &DebugPortDevice->BaudRate, + &((UART_DEVICE_PATH *) DevicePath)->BaudRate, + sizeof (((UART_DEVICE_PATH *) DevicePath)->BaudRate) + ); + DebugPortDevice->ReceiveFifoDepth = DEBUGPORT_UART_DEFAULT_FIFO_DEPTH; + DebugPortDevice->Timeout = DEBUGPORT_UART_DEFAULT_TIMEOUT; + gBS->CopyMem ( + &DebugPortDevice->Parity, + &((UART_DEVICE_PATH *) DevicePath)->Parity, + sizeof (((UART_DEVICE_PATH *) DevicePath)->Parity) + ); + gBS->CopyMem ( + &DebugPortDevice->DataBits, + &((UART_DEVICE_PATH *) DevicePath)->DataBits, + sizeof (((UART_DEVICE_PATH *) DevicePath)->DataBits) + ); + gBS->CopyMem ( + &DebugPortDevice->StopBits, + &((UART_DEVICE_PATH *) DevicePath)->StopBits, + sizeof (((UART_DEVICE_PATH *) DevicePath)->StopBits) + ); + } + } + } +} + +EFI_STATUS +EFIAPI +ImageUnloadHandler ( + EFI_HANDLE ImageHandle + ) +/*++ + +Routine Description: + Unload function that is registered in the LoadImage protocol. It un-installs + protocols produced and deallocates pool used by the driver. Called by the core + when unloading the driver. + +Arguments: + EFI_HANDLE ImageHandle + +Returns: + + EFI_SUCCESS + +--*/ +{ + EFI_STATUS Status; + + if (gDebugPortDevice->SerialIoBinding != NULL) { + return EFI_ABORTED; + } + + Status = gBS->UninstallMultipleProtocolInterfaces ( + ImageHandle, + &gEfiDriverBindingProtocolGuid, + &gDebugPortDevice->DriverBindingInterface, + &gEfiComponentNameProtocolGuid, + &gDebugPortDevice->ComponentNameInterface, + NULL + ); + + if (EFI_ERROR (Status)) { + return Status; + } + // + // Clean up allocations + // + if (gDebugPortDevice->DebugPortVariable != NULL) { + gBS->FreePool (gDebugPortDevice->DebugPortVariable); + } + + gBS->FreePool (gDebugPortDevice); + + return EFI_SUCCESS; +} diff --git a/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.dxs b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.dxs new file mode 100644 index 0000000..280931b --- /dev/null +++ b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.dxs @@ -0,0 +1,26 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + DebugPort.dxs + +Abstract: + + Dependency expression source file. + +--*/ +#include +#include + +DEPENDENCY_START + TRUE +DEPENDENCY_END diff --git a/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.h b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.h new file mode 100644 index 0000000..bb486c3 --- /dev/null +++ b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.h @@ -0,0 +1,172 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + DebugPort.h + +Abstract: + Definitions and prototypes for DebugPort driver + +--*/ + +#ifndef __DEBUGPORT_H__ +#define __DEBUGPORT_H__ + + +// +// local type definitions +// +#define DEBUGPORT_DEVICE_SIGNATURE EFI_SIGNATURE_32 ('D', 'B', 'G', 'P') + +// +// Device structure used by driver +// +typedef struct { + UINT32 Signature; + EFI_HANDLE DriverBindingHandle; + EFI_HANDLE DebugPortDeviceHandle; + VOID *DebugPortVariable; + + EFI_DRIVER_BINDING_PROTOCOL DriverBindingInterface; + EFI_COMPONENT_NAME_PROTOCOL ComponentNameInterface; + EFI_DEVICE_PATH_PROTOCOL *DebugPortDevicePath; + EFI_DEBUGPORT_PROTOCOL DebugPortInterface; + + EFI_HANDLE SerialIoDeviceHandle; + EFI_SERIAL_IO_PROTOCOL *SerialIoBinding; + UINT64 BaudRate; + UINT32 ReceiveFifoDepth; + UINT32 Timeout; + EFI_PARITY_TYPE Parity; + UINT8 DataBits; + EFI_STOP_BITS_TYPE StopBits; +} DEBUGPORT_DEVICE; + +#define DEBUGPORT_DEVICE_FROM_THIS(a) CR (a, DEBUGPORT_DEVICE, DebugPortInterface, DEBUGPORT_DEVICE_SIGNATURE) + +#define EFI_ACPI_PC_COMPORT_HID EISA_PNP_ID (0x0500) +#define EFI_ACPI_16550UART_HID EISA_PNP_ID (0x0501) + +#define DEBUGPORT_UART_DEFAULT_BAUDRATE 115200 +#define DEBUGPORT_UART_DEFAULT_PARITY 0 +#define DEBUGPORT_UART_DEFAULT_FIFO_DEPTH 16 +#define DEBUGPORT_UART_DEFAULT_TIMEOUT 50000 // 5 ms +#define DEBUGPORT_UART_DEFAULT_DATA_BITS 8 +#define DEBUGPORT_UART_DEFAULT_STOP_BITS 1 + +#define DEBUGPORT_DRIVER_VERSION 1 + +#define EfiIsUartDevicePath(dp) (DevicePathType (dp) == MESSAGING_DEVICE_PATH && DevicePathSubType (dp) == MSG_UART_DP) + +// +// globals +// +extern DEBUGPORT_DEVICE *gDebugPortDevice; + +// +// Driver binding interface functions... +// +EFI_STATUS +DebugPortEntryPoint ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +; + +EFI_STATUS +EFIAPI +DebugPortSupported ( + IN EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE Controller, + IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath + ) +; + +EFI_STATUS +EFIAPI +DebugPortStart ( + IN EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE Controller, + IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath + ) +; + +EFI_STATUS +EFIAPI +DebugPortStop ( + IN EFI_DRIVER_BINDING_PROTOCOL *This, + IN EFI_HANDLE Controller, + IN UINTN NumberOfChildren, + IN EFI_HANDLE *ChildHandleBuffer + ) +; + +// +// EFI Component Name Functions +// +EFI_STATUS +EFIAPI +DebugPortComponentNameGetDriverName ( + IN EFI_COMPONENT_NAME_PROTOCOL *This, + IN CHAR8 *Language, + OUT CHAR16 **DriverName + ) +; + +EFI_STATUS +EFIAPI +DebugPortComponentNameGetControllerName ( + IN EFI_COMPONENT_NAME_PROTOCOL *This, + IN EFI_HANDLE ControllerHandle, + IN EFI_HANDLE ChildHandle OPTIONAL, + IN CHAR8 *Language, + OUT CHAR16 **ControllerName + ) +; + +// +// DebugPort member functions +// +EFI_STATUS +EFIAPI +DebugPortReset ( + IN EFI_DEBUGPORT_PROTOCOL *This + ) +; + +EFI_STATUS +EFIAPI +DebugPortRead ( + IN EFI_DEBUGPORT_PROTOCOL *This, + IN UINT32 Timeout, + IN OUT UINTN *BufferSize, + IN VOID *Buffer + ) +; + +EFI_STATUS +EFIAPI +DebugPortWrite ( + IN EFI_DEBUGPORT_PROTOCOL *This, + IN UINT32 Timeout, + IN OUT UINTN *BufferSize, + OUT VOID *Buffer + ) +; + +EFI_STATUS +EFIAPI +DebugPortPoll ( + IN EFI_DEBUGPORT_PROTOCOL *This + ) +; + +#endif diff --git a/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.mbd b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.mbd new file mode 100644 index 0000000..62abeee --- /dev/null +++ b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.mbd @@ -0,0 +1,46 @@ + + + + + DebugPort + 73E9457A-CEA1-4917-9A9C-9F1F0F0FD322 + 0 + FIX ME! + Copyright (c) 2004-2006, Intel Corporation + + All rights reserved. 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. + + 2006-03-12 17:09 + 2006-03-19 15:19 + + + UefiBootServicesTableLib + UefiRuntimeServicesTableLib + UefiMemoryLib + UefiLib + UefiDriverEntryPoint + UefiDriverModelLib + DxeReportStatusCodeLib + BaseDebugLibReportStatusCode + BaseLib + DxeMemoryAllocationLib + UefiDevicePathLib + + + _ModuleEntryPoint + + diff --git a/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.msa b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.msa new file mode 100644 index 0000000..6762026 --- /dev/null +++ b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/DebugPort.msa @@ -0,0 +1,77 @@ + + + + + DebugPort + UEFI_DRIVER + BS_DRIVER + 73E9457A-CEA1-4917-9A9C-9F1F0F0FD322 + 0 + Component description file for DiskIo module. + FIX ME! + Copyright (c) 2004-2006, Intel Corporation + + All rights reserved. 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. + + 0 + 2006-03-12 17:09 + 2006-03-19 15:19 + + + DebugLib + UefiDriverModelLib + UefiDriverEntryPoint + UefiLib + BaseLib + BaseMemoryLib + MemoryAllocationLib + UefiBootServicesTableLib + UefiRuntimeServicesTableLib + DevicePathLib + + + DebugPort.h + DebugPort.c + ComponentName.c + DebugPort.dxs + + + MdePkg + EdkModulePkg + + + DebugPort + DevicePath + SerialIo + + + + DEBUGPORT + 0xEBA4E8D2, 0x3858, 0x41EC, 0xA2, 0x81, 0x26, 0x47, 0xBA, 0x96, 0x60, 0xD0 + + + + + InitializeDebugPortDriver + ImageUnloadHandler + + + gDebugPortDriverBinding + gDebugPortComponentName + + + diff --git a/EdkModulePkg/Universal/Debugger/Debugport/Dxe/build.xml b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/build.xml new file mode 100644 index 0000000..89b603c --- /dev/null +++ b/EdkModulePkg/Universal/Debugger/Debugport/Dxe/build.xml @@ -0,0 +1,47 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file -- cgit v1.1