Serial.h

Go to the documentation of this file.

 
#ifndef _SERIAL_H_
#define _SERIAL_H_
 
#include <Uefi.h>
 
#include <IndustryStandard/Pci.h>
 
#include <Protocol/SuperIo.h>
#include <Protocol/PciIo.h>
#include <Protocol/SerialIo.h>
#include <Protocol/DevicePath.h>
 
#include <Library/DebugLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/UefiLib.h>
#include <Library/DevicePathLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/ReportStatusCodeLib.h>
#include <Library/PcdLib.h>
#include <Library/IoLib.h>
#include <Library/PrintLib.h>
 
//
// Driver Binding Externs
//
extern EFI_DRIVER_BINDING_PROTOCOL   gSerialControllerDriver;
extern EFI_COMPONENT_NAME_PROTOCOL   gPciSioSerialComponentName;
extern EFI_COMPONENT_NAME2_PROTOCOL  gPciSioSerialComponentName2;
 
#define SIO_SERIAL_PORT_NAME  L"SIO Serial Port #%d"
#define PCI_SERIAL_PORT_NAME  L"PCI Serial Port #%d"
#define SERIAL_PORT_NAME_LEN  (sizeof (SIO_SERIAL_PORT_NAME) / sizeof (CHAR16) + MAXIMUM_VALUE_CHARACTERS)
 
//
// Internal Data Structures
//
#define TIMEOUT_STALL_INTERVAL  10
 
#pragma pack(1)
typedef struct {
  UINT16    VendorId;          
  UINT16    DeviceId;          
  UINT32    ClockRate;         
  UINT64    Offset;            
  UINT8     BarIndex;          
  UINT8     RegisterStride;    
  UINT16    ReceiveFifoDepth;  
  UINT16    TransmitFifoDepth; 
  UINT8     Reserved[2];
} PCI_SERIAL_PARAMETER;
#pragma pack()
 
#define SERIAL_MAX_FIFO_SIZE  17      
typedef struct {
  UINT16    Head;                       
  UINT16    Tail;                       
  UINT8     Data[SERIAL_MAX_FIFO_SIZE]; 
} SERIAL_DEV_FIFO;
 
typedef union {
  EFI_PCI_IO_PROTOCOL    *PciIo;
  EFI_SIO_PROTOCOL       *Sio;
} PARENT_IO_PROTOCOL_PTR;
 
typedef struct {
  EFI_PCI_IO_PROTOCOL    *PciIo;          // Pointer to parent PciIo instance.
  UINTN                  ChildCount;      // Count of child SerialIo instance.
  UINT64                 PciAttributes;   // Original PCI attributes.
} PCI_DEVICE_INFO;
 
typedef struct {
  UINT32                      Signature;
  EFI_HANDLE                  Handle;
  EFI_SERIAL_IO_PROTOCOL      SerialIo;
  EFI_SERIAL_IO_MODE          SerialMode;
  EFI_DEVICE_PATH_PROTOCOL    *DevicePath;
 
  EFI_DEVICE_PATH_PROTOCOL    *ParentDevicePath;
  UART_DEVICE_PATH            UartDevicePath;
 
  EFI_PHYSICAL_ADDRESS        BaseAddress;    
  BOOLEAN                     MmioAccess;     
  UINT8                       RegisterStride; 
  UINT32                      ClockRate;      
 
  UINT16                      ReceiveFifoDepth; 
  SERIAL_DEV_FIFO             Receive;          
 
  UINT16                      TransmitFifoDepth; 
  SERIAL_DEV_FIFO             Transmit;          
 
  BOOLEAN                     SoftwareLoopbackEnable;
  BOOLEAN                     HardwareFlowControl;
  EFI_UNICODE_STRING_TABLE    *ControllerNameTable;
  BOOLEAN                     ContainsControllerNode; 
  UINT32                      Instance;
  PCI_DEVICE_INFO             *PciDeviceInfo;
} SERIAL_DEV;
 
#define SERIAL_DEV_SIGNATURE  SIGNATURE_32 ('s', 'e', 'r', 'd')
#define SERIAL_DEV_FROM_THIS(a)  CR (a, SERIAL_DEV, SerialIo, SERIAL_DEV_SIGNATURE)
 
//
// Serial Driver Defaults
//
#define SERIAL_PORT_DEFAULT_TIMEOUT       1000000
#define SERIAL_PORT_SUPPORT_CONTROL_MASK  (EFI_SERIAL_CLEAR_TO_SEND                |       \
                                                 EFI_SERIAL_DATA_SET_READY               | \
                                                 EFI_SERIAL_RING_INDICATE                | \
                                                 EFI_SERIAL_CARRIER_DETECT               | \
                                                 EFI_SERIAL_REQUEST_TO_SEND              | \
                                                 EFI_SERIAL_DATA_TERMINAL_READY          | \
                                                 EFI_SERIAL_HARDWARE_LOOPBACK_ENABLE     | \
                                                 EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE     | \
                                                 EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE | \
                                                 EFI_SERIAL_OUTPUT_BUFFER_EMPTY          | \
                                                 EFI_SERIAL_INPUT_BUFFER_EMPTY)
 
#define SERIAL_PORT_MIN_TIMEOUT  1                    // 1 uS
#define SERIAL_PORT_MAX_TIMEOUT  100000000            // 100 seconds
//
// UART Registers
//
#define SERIAL_REGISTER_THR  0 
#define SERIAL_REGISTER_RBR  0 
#define SERIAL_REGISTER_DLL  0 
#define SERIAL_REGISTER_DLM  1 
#define SERIAL_REGISTER_IER  1 
#define SERIAL_REGISTER_IIR  2 
#define SERIAL_REGISTER_FCR  2 
#define SERIAL_REGISTER_LCR  3 
#define SERIAL_REGISTER_MCR  4 
#define SERIAL_REGISTER_LSR  5 
#define SERIAL_REGISTER_MSR  6 
#define SERIAL_REGISTER_SCR  7 
#pragma pack(1)
 
typedef union {
  struct {
    UINT8    Ravie    : 1; 
    UINT8    Theie    : 1; 
    UINT8    Rie      : 1; 
    UINT8    Mie      : 1; 
    UINT8    Reserved : 4;
  } Bits;
  UINT8    Data;
} SERIAL_PORT_IER;
 
typedef union {
  struct {
    UINT8    TrFIFOE  : 1; 
    UINT8    ResetRF  : 1; 
    UINT8    ResetTF  : 1; 
    UINT8    Dms      : 1; 
    UINT8    Reserved : 1;
    UINT8    TrFIFO64 : 1; 
    UINT8    Rtb      : 2; 
  } Bits;
  UINT8    Data;
} SERIAL_PORT_FCR;
 
typedef union {
  struct {
    UINT8    SerialDB : 2; 
    UINT8    StopB    : 1; 
    UINT8    ParEn    : 1; 
    UINT8    EvenPar  : 1; 
    UINT8    SticPar  : 1; 
    UINT8    BrCon    : 1; 
    UINT8    DLab     : 1; 
  } Bits;
  UINT8    Data;
} SERIAL_PORT_LCR;
 
typedef union {
  struct {
    UINT8    DtrC     : 1; 
    UINT8    Rts      : 1; 
    UINT8    Out1     : 1; 
    UINT8    Out2     : 1; 
    UINT8    Lme      : 1; 
    UINT8    Reserved : 3;
  } Bits;
  UINT8    Data;
} SERIAL_PORT_MCR;
 
typedef union {
  struct {
    UINT8    Dr    : 1; 
    UINT8    Oe    : 1; 
    UINT8    Pe    : 1; 
    UINT8    Fe    : 1; 
    UINT8    Bi    : 1; 
    UINT8    Thre  : 1; 
    UINT8    Temt  : 1; 
    UINT8    FIFOe : 1; 
  } Bits;
  UINT8    Data;
} SERIAL_PORT_LSR;
 
typedef union {
  struct {
    UINT8    DeltaCTS       : 1; 
    UINT8    DeltaDSR       : 1; 
    UINT8    TrailingEdgeRI : 1; 
    UINT8    DeltaDCD       : 1; 
    UINT8    Cts            : 1; 
    UINT8    Dsr            : 1; 
    UINT8    Ri             : 1; 
    UINT8    Dcd            : 1; 
  } Bits;
  UINT8    Data;
} SERIAL_PORT_MSR;
 
#pragma pack()
//
// Define serial register I/O macros
//
#define READ_RBR(S)  SerialReadRegister (S, SERIAL_REGISTER_RBR)
#define READ_DLL(S)  SerialReadRegister (S, SERIAL_REGISTER_DLL)
#define READ_DLM(S)  SerialReadRegister (S, SERIAL_REGISTER_DLM)
#define READ_IER(S)  SerialReadRegister (S, SERIAL_REGISTER_IER)
#define READ_IIR(S)  SerialReadRegister (S, SERIAL_REGISTER_IIR)
#define READ_LCR(S)  SerialReadRegister (S, SERIAL_REGISTER_LCR)
#define READ_MCR(S)  SerialReadRegister (S, SERIAL_REGISTER_MCR)
#define READ_LSR(S)  SerialReadRegister (S, SERIAL_REGISTER_LSR)
#define READ_MSR(S)  SerialReadRegister (S, SERIAL_REGISTER_MSR)
#define READ_SCR(S)  SerialReadRegister (S, SERIAL_REGISTER_SCR)
 
#define WRITE_THR(S, D)  SerialWriteRegister (S, SERIAL_REGISTER_THR, D)
#define WRITE_DLL(S, D)  SerialWriteRegister (S, SERIAL_REGISTER_DLL, D)
#define WRITE_DLM(S, D)  SerialWriteRegister (S, SERIAL_REGISTER_DLM, D)
#define WRITE_IER(S, D)  SerialWriteRegister (S, SERIAL_REGISTER_IER, D)
#define WRITE_FCR(S, D)  SerialWriteRegister (S, SERIAL_REGISTER_FCR, D)
#define WRITE_LCR(S, D)  SerialWriteRegister (S, SERIAL_REGISTER_LCR, D)
#define WRITE_MCR(S, D)  SerialWriteRegister (S, SERIAL_REGISTER_MCR, D)
#define WRITE_LSR(S, D)  SerialWriteRegister (S, SERIAL_REGISTER_LSR, D)
#define WRITE_MSR(S, D)  SerialWriteRegister (S, SERIAL_REGISTER_MSR, D)
#define WRITE_SCR(S, D)  SerialWriteRegister (S, SERIAL_REGISTER_SCR, D)
 
//
// Prototypes
// Driver model protocol interface
//
 
EFI_STATUS
EFIAPI
SerialControllerDriverSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  );
 
EFI_STATUS
EFIAPI
SerialControllerDriverStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  );
 
EFI_STATUS
EFIAPI
SerialControllerDriverStop (
  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN  EFI_HANDLE                   Controller,
  IN  UINTN                        NumberOfChildren,
  IN  EFI_HANDLE                   *ChildHandleBuffer
  );
 
//
// Serial I/O Protocol Interface
//
 
EFI_STATUS
EFIAPI
SerialReset (
  IN EFI_SERIAL_IO_PROTOCOL  *This
  );
 
EFI_STATUS
EFIAPI
SerialSetAttributes (
  IN EFI_SERIAL_IO_PROTOCOL  *This,
  IN UINT64                  BaudRate,
  IN UINT32                  ReceiveFifoDepth,
  IN UINT32                  Timeout,
  IN EFI_PARITY_TYPE         Parity,
  IN UINT8                   DataBits,
  IN EFI_STOP_BITS_TYPE      StopBits
  );
 
EFI_STATUS
EFIAPI
SerialSetControl (
  IN EFI_SERIAL_IO_PROTOCOL  *This,
  IN UINT32                  Control
  );
 
EFI_STATUS
EFIAPI
SerialGetControl (
  IN EFI_SERIAL_IO_PROTOCOL  *This,
  OUT UINT32                 *Control
  );
 
EFI_STATUS
EFIAPI
SerialWrite (
  IN EFI_SERIAL_IO_PROTOCOL  *This,
  IN OUT UINTN               *BufferSize,
  IN VOID                    *Buffer
  );
 
EFI_STATUS
EFIAPI
SerialRead (
  IN EFI_SERIAL_IO_PROTOCOL  *This,
  IN OUT UINTN               *BufferSize,
  OUT VOID                   *Buffer
  );
 
//
// Internal Functions
//
 
BOOLEAN
SerialPresent (
  IN SERIAL_DEV  *SerialDevice
  );
 
BOOLEAN
SerialFifoFull (
  IN SERIAL_DEV_FIFO  *Fifo
  );
 
BOOLEAN
SerialFifoEmpty (
  IN SERIAL_DEV_FIFO  *Fifo
  );
 
EFI_STATUS
SerialFifoAdd (
  IN SERIAL_DEV_FIFO  *Fifo,
  IN UINT8            Data
  );
 
EFI_STATUS
SerialFifoRemove (
  IN  SERIAL_DEV_FIFO  *Fifo,
  OUT UINT8            *Data
  );
 
EFI_STATUS
SerialReceiveTransmit (
  IN SERIAL_DEV  *SerialDevice
  );
 
UINT8
SerialReadRegister (
  IN SERIAL_DEV  *SerialDev,
  IN UINT32      Offset
  );
 
VOID
SerialWriteRegister (
  IN SERIAL_DEV  *SerialDev,
  IN UINT32      Offset,
  IN UINT8       Data
  );
 
//
// EFI Component Name Functions
//
 
EFI_STATUS
EFIAPI
SerialComponentNameGetDriverName (
  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
  IN  CHAR8                        *Language,
  OUT CHAR16                       **DriverName
  );
 
EFI_STATUS
EFIAPI
SerialComponentNameGetControllerName (
  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
  IN  EFI_HANDLE                   ControllerHandle,
  IN  EFI_HANDLE                   ChildHandle        OPTIONAL,
  IN  CHAR8                        *Language,
  OUT CHAR16                       **ControllerName
  );
 
VOID
AddName (
  IN  SERIAL_DEV  *SerialDevice,
  IN  UINT32      Uid
  );
 
BOOLEAN
VerifyUartParameters (
  IN     UINT32              ClockRate,
  IN     UINT64              BaudRate,
  IN     UINT8               DataBits,
  IN     EFI_PARITY_TYPE     Parity,
  IN     EFI_STOP_BITS_TYPE  StopBits,
  OUT UINT64                 *Divisor,
  OUT UINT64                 *ActualBaudRate
  );
 
UART_DEVICE_PATH *
SkipControllerDevicePathNode (
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath,
  BOOLEAN                   *ContainsControllerNode,
  UINT32                    *ControllerNumber
  );
 
BOOLEAN
IsUartFlowControlDevicePathNode (
  IN UART_FLOW_CONTROL_DEVICE_PATH  *FlowControl
  );
 
#endif