CorebootPayloadPkg/Library/SerialPortLib/SerialPortLib.c

   1 /** @file
   2   SerialPortLib instance for UART device upon coreboot
   3
   4   Copyright (c) 2014, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include <Uefi/UefiBaseType.h>
  16 #include <Library/SerialPortLib.h>
  17 #include <Library/PcdLib.h>
  18 #include <Library/IoLib.h>
  19 #include <Library/CbParseLib.h>
  20
  21 //
  22 // 16550 UART register offsets and bitfields
  23 //
  24 #define R_UART_RXBUF          0
  25 #define R_UART_TXBUF          0
  26 #define R_UART_BAUD_LOW       0
  27 #define R_UART_BAUD_HIGH      1
  28 #define R_UART_FCR            2
  29 #define   B_UART_FCR_FIFOE    BIT0
  30 #define   B_UART_FCR_FIFO64   BIT5
  31 #define R_UART_LCR            3
  32 #define   B_UART_LCR_DLAB     BIT7
  33 #define R_UART_MCR            4
  34 #define   B_UART_MCR_RTS      BIT1
  35 #define R_UART_LSR            5
  36 #define   B_UART_LSR_RXRDY    BIT0
  37 #define   B_UART_LSR_TXRDY    BIT5
  38 #define   B_UART_LSR_TEMT     BIT6
  39 #define R_UART_MSR            6
  40 #define   B_UART_MSR_CTS      BIT4
  41 #define   B_UART_MSR_DSR      BIT5
  42
  43 UINT32 mSerialRegBase = 0;
  44 UINT32 mSerialRegAccessType = 0;
  45
  46 /**
  47   Read an 8-bit 16550 register.  If PcdSerialUseMmio is TRUE, then the value is read from
  48   MMIO space.  If PcdSerialUseMmio is FALSE, then the value is read from I/O space.  The
  49   parameter Offset is added to the base address of the 16550 registers that is specified
  50   by PcdSerialRegisterBase.
  51
  52   @param  Offset  The offset of the 16550 register to read.
  53
  54   @return The value read from the 16550 register.
  55
  56 **/
  57 UINT8
  58 SerialPortReadRegister (
  59   UINTN  Offset
  60   )
  61 {
  62   if (mSerialRegAccessType == 2) { //MMIO
  63     return MmioRead8 (mSerialRegBase + Offset);
  64   } else { //IO
  65     return IoRead8 ((UINT16)mSerialRegBase + Offset);
  66   }
  67 }
  68
  69 /**
  70   Write an 8-bit 16550 register.  If PcdSerialUseMmio is TRUE, then the value is written to
  71   MMIO space.  If PcdSerialUseMmio is FALSE, then the value is written to I/O space.  The
  72   parameter Offset is added to the base address of the 16550 registers that is specified
  73   by PcdSerialRegisterBase.
  74
  75   @param  Offset  The offset of the 16550 register to write.
  76   @param  Value   The value to write to the 16550 register specified by Offset.
  77
  78   @return The value written to the 16550 register.
  79
  80 **/
  81 UINT8
  82 SerialPortWriteRegister (
  83   UINTN  Offset,
  84   UINT8  Value
  85   )
  86 {
  87   if (mSerialRegAccessType == 2) { //MMIO
  88     return MmioWrite8 (mSerialRegBase + Offset, Value);
  89   } else {// IO
  90     return IoWrite8 ((UINT16)mSerialRegBase + Offset, Value);
  91   }
  92 }
  93
  94 /**
  95   Initialize the serial device hardware.
  96
  97   If no initialization is required, then return RETURN_SUCCESS.
  98   If the serial device was successfully initialized, then return RETURN_SUCCESS.
  99   If the serial device could not be initialized, then return RETURN_DEVICE_ERROR.
 100
 101   @retval RETURN_SUCCESS        The serial device was initialized.
 102   @retval RETURN_DEVICE_ERROR   The serial device could not be initialized.
 103
 104 **/
 105 RETURN_STATUS
 106 EFIAPI
 107 SerialPortInitialize (
 108   VOID
 109   )
 110 {
 111   RETURN_STATUS  Status;
 112   UINTN          Divisor;
 113   BOOLEAN        Initialized;
 114
 115   Status = CbParseSerialInfo (&mSerialRegBase, &mSerialRegAccessType, NULL);
 116   if (RETURN_ERROR (Status)) {
 117     return Status;
 118   }
 119
 120   //
 121   // See if the serial port is already initialized
 122   //
 123   Initialized = TRUE;
 124   if ((SerialPortReadRegister (R_UART_FCR) & (B_UART_FCR_FIFOE | B_UART_FCR_FIFO64)) !=
 125       (PcdGet8 (PcdSerialFifoControl)      & (B_UART_FCR_FIFOE | B_UART_FCR_FIFO64))     ) {
 126     Initialized = FALSE;
 127   }
 128
 129   if ((SerialPortReadRegister (R_UART_LCR) & 0x3F) != (PcdGet8 (PcdSerialLineControl) & 0x3F)) {
 130     Initialized = FALSE;
 131   }
 132   SerialPortWriteRegister (R_UART_LCR, (UINT8)(SerialPortReadRegister (R_UART_LCR) | B_UART_LCR_DLAB));
 133   Divisor =  SerialPortReadRegister (R_UART_BAUD_HIGH) << 8;
 134   Divisor |= SerialPortReadRegister (R_UART_BAUD_LOW);
 135   SerialPortWriteRegister (R_UART_LCR, (UINT8)(SerialPortReadRegister (R_UART_LCR) & ~B_UART_LCR_DLAB));
 136   if (Divisor != 115200 / PcdGet32 (PcdSerialBaudRate)) {
 137     Initialized = FALSE;
 138   }
 139   if (Initialized) {
 140     return RETURN_SUCCESS;
 141   }
 142
 143   //
 144   // Configure baud rate
 145   //
 146   Divisor = 115200 / PcdGet32 (PcdSerialBaudRate);
 147   SerialPortWriteRegister (R_UART_LCR, B_UART_LCR_DLAB);
 148   SerialPortWriteRegister (R_UART_BAUD_HIGH, (UINT8) (Divisor >> 8));
 149   SerialPortWriteRegister (R_UART_BAUD_LOW, (UINT8) (Divisor & 0xff));
 150
 151   //
 152   // Clear DLAB and configure Data Bits, Parity, and Stop Bits.
 153   // Strip reserved bits from PcdSerialLineControl
 154   //
 155   SerialPortWriteRegister (R_UART_LCR, (UINT8)(PcdGet8 (PcdSerialLineControl) & 0x3F));
 156
 157   //
 158   // Enable and reset FIFOs
 159   // Strip reserved bits from PcdSerialFifoControl
 160   //
 161   SerialPortWriteRegister (R_UART_FCR, (UINT8)(PcdGet8 (PcdSerialFifoControl) & 0x27));
 162
 163   //
 164   // Put Modem Control Register(MCR) into its reset state of 0x00.
 165   //
 166   SerialPortWriteRegister (R_UART_MCR, 0x00);
 167
 168   return RETURN_SUCCESS;
 169 }
 170
 171 /**
 172   Write data from buffer to serial device.
 173
 174   Writes NumberOfBytes data bytes from Buffer to the serial device.
 175   The number of bytes actually written to the serial device is returned.
 176   If the return value is less than NumberOfBytes, then the write operation failed.
 177
 178   If Buffer is NULL, then ASSERT().
 179
 180   If NumberOfBytes is zero, then return 0.
 181
 182   @param  Buffer           Pointer to the data buffer to be written.
 183   @param  NumberOfBytes    Number of bytes to written to the serial device.
 184
 185   @retval 0                NumberOfBytes is 0.
 186   @retval >0               The number of bytes written to the serial device.
 187                            If this value is less than NumberOfBytes, then the read operation failed.
 188
 189 **/
 190 UINTN
 191 EFIAPI
 192 SerialPortWrite (
 193   IN UINT8     *Buffer,
 194   IN UINTN     NumberOfBytes
 195 )
 196 {
 197   UINTN    Result;
 198   UINTN    Index;
 199   UINTN    FifoSize;
 200
 201   if (Buffer == NULL) {
 202     return 0;
 203   }
 204
 205   if (NumberOfBytes == 0) {
 206     //
 207     // Flush the hardware
 208     //
 209
 210     //
 211     // Wait for both the transmit FIFO and shift register empty.
 212     //
 213     while ((SerialPortReadRegister (R_UART_LSR) & B_UART_LSR_TEMT) == 0);
 214
 215     return 0;
 216   }
 217
 218   //
 219   // Compute the maximum size of the Tx FIFO
 220   //
 221   FifoSize = 1;
 222   if ((PcdGet8 (PcdSerialFifoControl) & B_UART_FCR_FIFOE) != 0) {
 223     if ((PcdGet8 (PcdSerialFifoControl) & B_UART_FCR_FIFO64) == 0) {
 224       FifoSize = 16;
 225     } else {
 226       FifoSize = 64;
 227     }
 228   }
 229
 230   Result = NumberOfBytes;
 231   while (NumberOfBytes != 0) {
 232     //
 233     // Wait for the serial port to be ready, to make sure both the transmit FIFO
 234     // and shift register empty.
 235     //
 236     while ((SerialPortReadRegister (R_UART_LSR) & B_UART_LSR_TEMT) == 0);
 237
 238     //
 239     // Fill then entire Tx FIFO
 240     //
 241     for (Index = 0; Index < FifoSize && NumberOfBytes != 0; Index++, NumberOfBytes--, Buffer++) {
 242
 243       //
 244       // Write byte to the transmit buffer.
 245       //
 246       SerialPortWriteRegister (R_UART_TXBUF, *Buffer);
 247     }
 248   }
 249   return Result;
 250 }
 251
 252 /**
 253   Reads data from a serial device into a buffer.
 254
 255   @param  Buffer           Pointer to the data buffer to store the data read from the serial device.
 256   @param  NumberOfBytes    Number of bytes to read from the serial device.
 257
 258   @retval 0                NumberOfBytes is 0.
 259   @retval >0               The number of bytes read from the serial device.
 260                            If this value is less than NumberOfBytes, then the read operation failed.
 261
 262 **/
 263 UINTN
 264 EFIAPI
 265 SerialPortRead (
 266   OUT UINT8     *Buffer,
 267   IN  UINTN     NumberOfBytes
 268 )
 269 {
 270   UINTN  Result;
 271
 272   if (NULL == Buffer) {
 273     return 0;
 274   }
 275
 276   for (Result = 0; NumberOfBytes-- != 0; Result++, Buffer++) {
 277     //
 278     // Wait for the serial port to have some data.
 279     //
 280     while ((SerialPortReadRegister (R_UART_LSR) & B_UART_LSR_RXRDY) == 0);
 281
 282     //
 283     // Read byte from the receive buffer.
 284     //
 285     *Buffer = SerialPortReadRegister (R_UART_RXBUF);
 286   }
 287
 288   return Result;
 289 }
 290
 291 /**
 292   Polls a serial device to see if there is any data waiting to be read.
 293
 294   Polls aserial device to see if there is any data waiting to be read.
 295   If there is data waiting to be read from the serial device, then TRUE is returned.
 296   If there is no data waiting to be read from the serial device, then FALSE is returned.
 297
 298   @retval TRUE             Data is waiting to be read from the serial device.
 299   @retval FALSE            There is no data waiting to be read from the serial device.
 300
 301 **/
 302 BOOLEAN
 303 EFIAPI
 304 SerialPortPoll (
 305   VOID
 306   )
 307 {
 308   //
 309   // Read the serial port status
 310   //
 311   if ((SerialPortReadRegister (R_UART_LSR) & B_UART_LSR_RXRDY) != 0) {
 312     return TRUE;
 313   }
 314
 315   return FALSE;
 316 }