EmbeddedPkg/SerialDxe/SerialIo.c

   1 /** @file
   2   Serial IO Abstraction for GDB stub. This allows an EFI consoles that shows up on the system
   3   running GDB. One console for error information and another console for user input/output.
   4
   5   Basic packet format is $packet-data#checksum. So every command has 4 bytes of overhead: $,
   6   #, 0, 0. The 0 and 0 are the ascii characters for the checksum.
   7
   8
   9   Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
  10   Copyright (c) 2013, ARM Ltd. All rights reserved.<BR>
  11
  12   This program and the accompanying materials
  13   are licensed and made available under the terms and conditions of the BSD License
  14   which accompanies this distribution.  The full text of the license may be found at
  15   http://opensource.org/licenses/bsd-license.php
  16
  17   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  18   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  19
  20 **/
  21
  22 #include <PiDxe.h>
  23 #include <Library/UefiLib.h>
  24 #include <Library/UefiBootServicesTableLib.h>
  25 #include <Library/DebugLib.h>
  26 #include <Library/SerialPortLib.h>
  27 #include <Library/SerialPortExtLib.h>
  28 #include <Library/PcdLib.h>
  29
  30 #include <Protocol/SerialIo.h>
  31
  32 typedef struct {
  33   VENDOR_DEVICE_PATH        Guid;
  34   UART_DEVICE_PATH          Uart;
  35   EFI_DEVICE_PATH_PROTOCOL  End;
  36 } SIMPLE_TEXT_OUT_DEVICE_PATH;
  37
  38 SIMPLE_TEXT_OUT_DEVICE_PATH mDevicePath = {
  39   {
  40     { HARDWARE_DEVICE_PATH, HW_VENDOR_DP, sizeof (VENDOR_DEVICE_PATH), 0},
  41     EFI_CALLER_ID_GUID // Use the drivers GUID
  42   },
  43   {
  44     { MESSAGING_DEVICE_PATH, MSG_UART_DP, sizeof (UART_DEVICE_PATH), 0},
  45     0,        // Reserved
  46     FixedPcdGet64 (PcdUartDefaultBaudRate),   // BaudRate
  47     FixedPcdGet8 (PcdUartDefaultDataBits),    // DataBits
  48     FixedPcdGet8 (PcdUartDefaultParity),      // Parity (N)
  49     FixedPcdGet8 (PcdUartDefaultStopBits)     // StopBits
  50   },
  51   { END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, sizeof (EFI_DEVICE_PATH_PROTOCOL), 0}
  52 };
  53
  54 EFI_HANDLE  gHandle = NULL;
  55
  56 /**
  57   Reset the serial device.
  58
  59   @param  This              Protocol instance pointer.
  60
  61   @retval EFI_SUCCESS       The device was reset.
  62   @retval EFI_DEVICE_ERROR  The serial device could not be reset.
  63
  64 **/
  65 EFI_STATUS
  66 EFIAPI
  67 SerialReset (
  68   IN EFI_SERIAL_IO_PROTOCOL  *This
  69   )
  70 {
  71   EFI_STATUS  Status;
  72   EFI_TPL     Tpl;
  73
  74   Status = SerialPortInitialize ();
  75   if (EFI_ERROR(Status)) {
  76     return Status;
  77   }
  78
  79   //
  80   // Set the Serial I/O mode and update the device path
  81   //
  82
  83   Tpl = gBS->RaiseTPL (TPL_NOTIFY);
  84
  85   //
  86   // Set the Serial I/O mode
  87   //
  88   This->Mode->ReceiveFifoDepth  = 0;
  89   This->Mode->Timeout           = 1000000;
  90   This->Mode->BaudRate          = PcdGet64 (PcdUartDefaultBaudRate);
  91   This->Mode->DataBits          = (UINT32)PcdGet8 (PcdUartDefaultDataBits);
  92   This->Mode->Parity            = (UINT32)PcdGet8 (PcdUartDefaultParity);
  93   This->Mode->StopBits          = (UINT32)PcdGet8 (PcdUartDefaultStopBits);
  94
  95   //
  96   // Check if the device path has actually changed
  97   //
  98   if (mDevicePath.Uart.BaudRate == This->Mode->BaudRate &&
  99       mDevicePath.Uart.DataBits == (UINT8)This->Mode->DataBits &&
 100       mDevicePath.Uart.Parity   == (UINT8)This->Mode->Parity &&
 101       mDevicePath.Uart.StopBits == (UINT8)This->Mode->StopBits
 102      ) {
 103     gBS->RestoreTPL (Tpl);
 104     return EFI_SUCCESS;
 105   }
 106
 107   //
 108   // Update the device path
 109   //
 110   mDevicePath.Uart.BaudRate = This->Mode->BaudRate;
 111   mDevicePath.Uart.DataBits = (UINT8)This->Mode->DataBits;
 112   mDevicePath.Uart.Parity   = (UINT8)This->Mode->Parity;
 113   mDevicePath.Uart.StopBits = (UINT8)This->Mode->StopBits;
 114
 115   Status = gBS->ReinstallProtocolInterface (
 116                   gHandle,
 117                   &gEfiDevicePathProtocolGuid,
 118                   &mDevicePath,
 119                   &mDevicePath
 120                   );
 121
 122   gBS->RestoreTPL (Tpl);
 123
 124   return Status;
 125 }
 126
 127
 128 /**
 129   Sets the baud rate, receive FIFO depth, transmit/receive time out, parity,
 130   data buts, and stop bits on a serial device.
 131
 132   @param  This             Protocol instance pointer.
 133   @param  BaudRate         The requested baud rate. A BaudRate value of 0 will use the the
 134                            device's default interface speed.
 135   @param  ReceiveFifoDepth The requested depth of the FIFO on the receive side of the
 136                            serial interface. A ReceiveFifoDepth value of 0 will use
 137                            the device's default FIFO depth.
 138   @param  Timeout          The requested time out for a single character in microseconds.
 139                            This timeout applies to both the transmit and receive side of the
 140                            interface. A Timeout value of 0 will use the device's default time
 141                            out value.
 142   @param  Parity           The type of parity to use on this serial device. A Parity value of
 143                            DefaultParity will use the device's default parity value.
 144   @param  DataBits         The number of data bits to use on the serial device. A DataBits
 145                            value of 0 will use the device's default data bit setting.
 146   @param  StopBits         The number of stop bits to use on this serial device. A StopBits
 147                            value of DefaultStopBits will use the device's default number of
 148                            stop bits.
 149
 150   @retval EFI_SUCCESS      The device was reset.
 151   @retval EFI_DEVICE_ERROR The serial device could not be reset.
 152
 153 **/
 154 EFI_STATUS
 155 EFIAPI
 156 SerialSetAttributes (
 157   IN EFI_SERIAL_IO_PROTOCOL  *This,
 158   IN UINT64                  BaudRate,
 159   IN UINT32                  ReceiveFifoDepth,
 160   IN UINT32                  Timeout,
 161   IN EFI_PARITY_TYPE         Parity,
 162   IN UINT8                   DataBits,
 163   IN EFI_STOP_BITS_TYPE      StopBits
 164   )
 165 {
 166   EFI_STATUS  Status;
 167   EFI_TPL     Tpl;
 168
 169   Status = SerialPortSetAttributes (&BaudRate, &ReceiveFifoDepth, &Timeout, &Parity, &DataBits, &StopBits);
 170   if (EFI_ERROR(Status)) {
 171     return Status;
 172   }
 173
 174   //
 175   // Set the Serial I/O mode and update the device path
 176   //
 177
 178   Tpl = gBS->RaiseTPL (TPL_NOTIFY);
 179
 180   //
 181   // Set the Serial I/O mode
 182   //
 183   This->Mode->BaudRate          = BaudRate;
 184   This->Mode->ReceiveFifoDepth  = ReceiveFifoDepth;
 185   This->Mode->Timeout           = Timeout;
 186   This->Mode->Parity            = (UINT32)Parity;
 187   This->Mode->DataBits          = (UINT32)DataBits;
 188   This->Mode->StopBits          = (UINT32)StopBits;
 189
 190   //
 191   // Check if the device path has actually changed
 192   //
 193   if (mDevicePath.Uart.BaudRate == BaudRate &&
 194       mDevicePath.Uart.Parity   == (UINT8)Parity &&
 195       mDevicePath.Uart.DataBits == DataBits &&
 196       mDevicePath.Uart.StopBits == (UINT8)StopBits
 197      ) {
 198     gBS->RestoreTPL (Tpl);
 199     return EFI_SUCCESS;
 200   }
 201
 202   //
 203   // Update the device path
 204   //
 205   mDevicePath.Uart.BaudRate = BaudRate;
 206   mDevicePath.Uart.DataBits = DataBits;
 207   mDevicePath.Uart.Parity   = (UINT8) Parity;
 208   mDevicePath.Uart.StopBits = (UINT8) StopBits;
 209
 210   Status = gBS->ReinstallProtocolInterface (
 211                   gHandle,
 212                   &gEfiDevicePathProtocolGuid,
 213                   &mDevicePath,
 214                   &mDevicePath
 215                   );
 216
 217   gBS->RestoreTPL (Tpl);
 218
 219   return Status;
 220 }
 221
 222
 223 /**
 224   Set the control bits on a serial device
 225
 226   @param  This             Protocol instance pointer.
 227   @param  Control          Set the bits of Control that are settable.
 228
 229   @retval EFI_SUCCESS      The new control bits were set on the serial device.
 230   @retval EFI_UNSUPPORTED  The serial device does not support this operation.
 231   @retval EFI_DEVICE_ERROR The serial device is not functioning correctly.
 232
 233 **/
 234 EFI_STATUS
 235 EFIAPI
 236 SerialSetControl (
 237   IN EFI_SERIAL_IO_PROTOCOL  *This,
 238   IN UINT32                  Control
 239   )
 240 {
 241   return SerialPortSetControl(Control);
 242 }
 243
 244
 245 /**
 246   Retrieves the status of the control bits on a serial device
 247
 248   @param  This              Protocol instance pointer.
 249   @param  Control           A pointer to return the current Control signals from the serial device.
 250
 251   @retval EFI_SUCCESS       The control bits were read from the serial device.
 252   @retval EFI_DEVICE_ERROR  The serial device is not functioning correctly.
 253
 254 **/
 255 EFI_STATUS
 256 EFIAPI
 257 SerialGetControl (
 258   IN EFI_SERIAL_IO_PROTOCOL  *This,
 259   OUT UINT32                 *Control
 260   )
 261 {
 262   return SerialPortGetControl(Control);
 263 }
 264
 265
 266 /**
 267   Writes data to a serial device.
 268
 269   @param  This              Protocol instance pointer.
 270   @param  BufferSize        On input, the size of the Buffer. On output, the amount of
 271                             data actually written.
 272   @param  Buffer            The buffer of data to write
 273
 274   @retval EFI_SUCCESS       The data was written.
 275   @retval EFI_DEVICE_ERROR  The device reported an error.
 276   @retval EFI_TIMEOUT       The data write was stopped due to a timeout.
 277
 278 **/
 279 EFI_STATUS
 280 EFIAPI
 281 SerialWrite (
 282   IN EFI_SERIAL_IO_PROTOCOL  *This,
 283   IN OUT UINTN               *BufferSize,
 284   IN VOID                    *Buffer
 285   )
 286 {
 287   UINTN Count;
 288
 289   Count = SerialPortWrite (Buffer, *BufferSize);
 290
 291   if (Count != *BufferSize) {
 292     *BufferSize = Count;
 293     return EFI_TIMEOUT;
 294   }
 295
 296   return EFI_SUCCESS;
 297 }
 298
 299 /**
 300   Reads data from a serial device.
 301
 302   @param  This              Protocol instance pointer.
 303   @param  BufferSize        On input, the size of the Buffer. On output, the amount of
 304                             data returned in Buffer.
 305   @param  Buffer            The buffer to return the data into.
 306
 307   @retval EFI_SUCCESS       The data was read.
 308   @retval EFI_DEVICE_ERROR  The device reported an error.
 309   @retval EFI_TIMEOUT       The data write was stopped due to a timeout.
 310
 311 **/
 312
 313 EFI_STATUS
 314 EFIAPI
 315 SerialRead (
 316   IN EFI_SERIAL_IO_PROTOCOL  *This,
 317   IN OUT UINTN               *BufferSize,
 318   OUT VOID                   *Buffer
 319   )
 320 {
 321   UINTN Count = 0;
 322
 323   if (SerialPortPoll()) {
 324     Count = SerialPortRead (Buffer, *BufferSize);
 325   }
 326
 327   if (Count != *BufferSize) {
 328     *BufferSize = Count;
 329     return EFI_TIMEOUT;
 330   }
 331
 332   return EFI_SUCCESS;
 333 }
 334
 335 //
 336 // Template used to initialize the GDB Serial IO protocols
 337 //
 338 EFI_SERIAL_IO_MODE gSerialIoMode = {
 339   0,                                          // ControlMask
 340   0,                                          // Timeout
 341   FixedPcdGet64 (PcdUartDefaultBaudRate),     // BaudRate
 342   1,                                          // ReceiveFifoDepth
 343   FixedPcdGet8 (PcdUartDefaultDataBits),      // DataBits
 344   FixedPcdGet8 (PcdUartDefaultParity),        // Parity
 345   FixedPcdGet8 (PcdUartDefaultStopBits)       // StopBits
 346 };
 347
 348
 349 EFI_SERIAL_IO_PROTOCOL gSerialIoTemplate = {
 350   SERIAL_IO_INTERFACE_REVISION,
 351   SerialReset,
 352   SerialSetAttributes,
 353   SerialSetControl,
 354   SerialGetControl,
 355   SerialWrite,
 356   SerialRead,
 357   &gSerialIoMode
 358 };
 359
 360 /**
 361   Initialize the state information for the Serial Io Protocol
 362
 363   @param  ImageHandle   of the loaded driver
 364   @param  SystemTable   Pointer to the System Table
 365
 366   @retval EFI_SUCCESS           Protocol registered
 367   @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure
 368   @retval EFI_DEVICE_ERROR      Hardware problems
 369
 370 **/
 371 EFI_STATUS
 372 EFIAPI
 373 SerialDxeInitialize (
 374   IN EFI_HANDLE         ImageHandle,
 375   IN EFI_SYSTEM_TABLE   *SystemTable
 376   )
 377 {
 378   EFI_STATUS      Status;
 379
 380   // Make a new handle with Serial IO protocol and its device path on it.
 381   Status = gBS->InstallMultipleProtocolInterfaces (
 382                   &gHandle,
 383                   &gEfiSerialIoProtocolGuid,   &gSerialIoTemplate,
 384                   &gEfiDevicePathProtocolGuid, &mDevicePath,
 385                   NULL
 386                   );
 387   ASSERT_EFI_ERROR (Status);
 388
 389   return Status;
 390 }
 391