MdeModulePkg/Universal/Console/ConSplitterDxe/ConSplitter.h

   1 /**@file
   2   Private data structures for the Console Splitter driver
   3
   4 Copyright (c) 2006 - 2007 Intel Corporation. <BR>
   5 All rights reserved. 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 #ifndef _CON_SPLITTER_H_
  16 #define _CON_SPLITTER_H_
  17
  18 #include <PiDxe.h>
  19 #include <Guid/PrimaryStandardErrorDevice.h>
  20 #include <Guid/PrimaryConsoleOutDevice.h>
  21 #include <Protocol/GraphicsOutput.h>
  22 #include <Guid/PrimaryConsoleInDevice.h>
  23 #include <Protocol/SimplePointer.h>
  24 #include <Protocol/AbsolutePointer.h>
  25 #include <Protocol/SimpleTextOut.h>
  26 #include <Guid/ConsoleInDevice.h>
  27 #include <Protocol/SimpleTextIn.h>
  28 #include <Protocol/SimpleTextInEx.h>
  29 #include <Protocol/ConsoleControl.h>
  30 #include <Guid/StandardErrorDevice.h>
  31 #include <Guid/ConsoleOutDevice.h>
  32 #include <Protocol/UgaDraw.h>
  33 #include <Library/PcdLib.h>
  34 #include <Library/DebugLib.h>
  35 #include <Library/UefiDriverEntryPoint.h>
  36 #include <Library/UefiLib.h>
  37 #include <Library/BaseLib.h>
  38 #include <Library/BaseMemoryLib.h>
  39 #include <Library/MemoryAllocationLib.h>
  40 #include <Library/UefiBootServicesTableLib.h>
  41
  42 //
  43 // Driver Binding Externs
  44 //
  45 extern EFI_DRIVER_BINDING_PROTOCOL  gConSplitterConInDriverBinding;
  46 extern EFI_COMPONENT_NAME_PROTOCOL  gConSplitterConInComponentName;
  47 extern EFI_COMPONENT_NAME2_PROTOCOL gConSplitterConInComponentName2;
  48 extern EFI_DRIVER_BINDING_PROTOCOL  gConSplitterSimplePointerDriverBinding;
  49 extern EFI_COMPONENT_NAME_PROTOCOL  gConSplitterSimplePointerComponentName;
  50 extern EFI_COMPONENT_NAME2_PROTOCOL gConSplitterSimplePointerComponentName2;
  51 extern EFI_COMPONENT_NAME_PROTOCOL  gConSplitterAbsolutePointerComponentName;
  52 extern EFI_COMPONENT_NAME2_PROTOCOL gConSplitterAbsolutePointerComponentName2;
  53 extern EFI_DRIVER_BINDING_PROTOCOL  gConSplitterConOutDriverBinding;
  54 extern EFI_COMPONENT_NAME_PROTOCOL  gConSplitterConOutComponentName;
  55 extern EFI_COMPONENT_NAME2_PROTOCOL gConSplitterConOutComponentName2;
  56 extern EFI_DRIVER_BINDING_PROTOCOL  gConSplitterStdErrDriverBinding;
  57 extern EFI_COMPONENT_NAME_PROTOCOL  gConSplitterStdErrComponentName;
  58 extern EFI_COMPONENT_NAME2_PROTOCOL gConSplitterStdErrComponentName2;
  59
  60 extern EFI_GUID                     gSimpleTextInExNotifyGuid;
  61
  62 // These definitions were in the old Hii protocol, but are not in the new UEFI
  63 // version. So they are defined locally.
  64 #define UNICODE_NARROW_CHAR   0xFFF0
  65 #define UNICODE_WIDE_CHAR     0xFFF1
  66
  67
  68 //
  69 // Private Data Structures
  70 //
  71 #define CONSOLE_SPLITTER_CONSOLES_ALLOC_UNIT  32
  72 #define CONSOLE_SPLITTER_MODES_ALLOC_UNIT     32
  73 #define MAX_STD_IN_PASSWORD                   80
  74
  75 typedef struct {
  76   UINTN Columns;
  77   UINTN Rows;
  78 } TEXT_OUT_SPLITTER_QUERY_DATA;
  79
  80 //
  81 // Private data for the EFI_SIMPLE_TEXT_INPUT_PROTOCOL splitter
  82 //
  83 #define TEXT_IN_SPLITTER_PRIVATE_DATA_SIGNATURE EFI_SIGNATURE_32 ('T', 'i', 'S', 'p')
  84
  85 #define TEXT_IN_EX_SPLITTER_NOTIFY_SIGNATURE EFI_SIGNATURE_32 ('T', 'i', 'S', 'n')
  86
  87 typedef struct _TEXT_IN_EX_SPLITTER_NOTIFY {
  88   UINTN                                 Signature;
  89   EFI_HANDLE                            *NotifyHandleList;
  90   EFI_HANDLE                            NotifyHandle;
  91   EFI_KEY_DATA                          KeyData;
  92   EFI_KEY_NOTIFY_FUNCTION               KeyNotificationFn;
  93   LIST_ENTRY                            NotifyEntry;
  94 } TEXT_IN_EX_SPLITTER_NOTIFY;
  95
  96 typedef struct {
  97   UINT64                             Signature;
  98   EFI_HANDLE                         VirtualHandle;
  99
 100   EFI_SIMPLE_TEXT_INPUT_PROTOCOL     TextIn;
 101   UINTN                              CurrentNumberOfConsoles;
 102   EFI_SIMPLE_TEXT_INPUT_PROTOCOL     **TextInList;
 103   UINTN                              TextInListCount;
 104
 105   EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  TextInEx;
 106   UINTN                              CurrentNumberOfExConsoles;
 107   EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  **TextInExList;
 108   UINTN                              TextInExListCount;
 109   LIST_ENTRY                         NotifyList;
 110
 111
 112   EFI_SIMPLE_POINTER_PROTOCOL        SimplePointer;
 113   EFI_SIMPLE_POINTER_MODE            SimplePointerMode;
 114   UINTN                              CurrentNumberOfPointers;
 115   EFI_SIMPLE_POINTER_PROTOCOL        **PointerList;
 116   UINTN                              PointerListCount;
 117
 118   EFI_ABSOLUTE_POINTER_PROTOCOL      AbsolutePointer;
 119   EFI_ABSOLUTE_POINTER_MODE          AbsolutePointerMode;
 120   UINTN                              CurrentNumberOfAbsolutePointers;
 121   EFI_ABSOLUTE_POINTER_PROTOCOL      **AbsolutePointerList;
 122   UINTN                              AbsolutePointerListCount;
 123   BOOLEAN                            AbsoluteInputEventSignalState;
 124
 125   BOOLEAN                            PasswordEnabled;
 126   CHAR16                             Password[MAX_STD_IN_PASSWORD];
 127   UINTN                              PwdIndex;
 128   CHAR16                             PwdAttempt[MAX_STD_IN_PASSWORD];
 129   EFI_EVENT                          LockEvent;
 130
 131   BOOLEAN                            KeyEventSignalState;
 132   BOOLEAN                            InputEventSignalState;
 133 } TEXT_IN_SPLITTER_PRIVATE_DATA;
 134
 135 #define TEXT_IN_SPLITTER_PRIVATE_DATA_FROM_THIS(a)  \
 136   CR ((a),                                            \
 137       TEXT_IN_SPLITTER_PRIVATE_DATA,                \
 138       TextIn,                                       \
 139       TEXT_IN_SPLITTER_PRIVATE_DATA_SIGNATURE       \
 140       )
 141
 142 #define TEXT_IN_SPLITTER_PRIVATE_DATA_FROM_SIMPLE_POINTER_THIS(a) \
 143   CR ((a),                                                          \
 144       TEXT_IN_SPLITTER_PRIVATE_DATA,                              \
 145       SimplePointer,                                              \
 146       TEXT_IN_SPLITTER_PRIVATE_DATA_SIGNATURE                     \
 147       )
 148 #define TEXT_IN_EX_SPLITTER_PRIVATE_DATA_FROM_THIS(a) \
 149   CR (a, \
 150       TEXT_IN_SPLITTER_PRIVATE_DATA, \
 151       TextInEx, \
 152       TEXT_IN_SPLITTER_PRIVATE_DATA_SIGNATURE \
 153       )
 154
 155 #define TEXT_IN_SPLITTER_PRIVATE_DATA_FROM_ABSOLUTE_POINTER_THIS(a) \
 156   CR (a, \
 157       TEXT_IN_SPLITTER_PRIVATE_DATA, \
 158       AbsolutePointer, \
 159       TEXT_IN_SPLITTER_PRIVATE_DATA_SIGNATURE \
 160       )
 161
 162 //
 163 // Private data for the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL splitter
 164 //
 165 #define TEXT_OUT_SPLITTER_PRIVATE_DATA_SIGNATURE  EFI_SIGNATURE_32 ('T', 'o', 'S', 'p')
 166
 167 typedef struct {
 168   EFI_GRAPHICS_OUTPUT_PROTOCOL     *GraphicsOutput;
 169   EFI_UGA_DRAW_PROTOCOL            *UgaDraw;
 170   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *TextOut;
 171   BOOLEAN                          TextOutEnabled;
 172 } TEXT_OUT_AND_GOP_DATA;
 173
 174 typedef struct {
 175   UINT64                             Signature;
 176   EFI_HANDLE                         VirtualHandle;
 177   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    TextOut;
 178   EFI_SIMPLE_TEXT_OUTPUT_MODE        TextOutMode;
 179
 180   EFI_UGA_DRAW_PROTOCOL              UgaDraw;
 181   UINT32                             UgaHorizontalResolution;
 182   UINT32                             UgaVerticalResolution;
 183   UINT32                             UgaColorDepth;
 184   UINT32                             UgaRefreshRate;
 185   EFI_UGA_PIXEL                      *UgaBlt;
 186
 187   EFI_GRAPHICS_OUTPUT_PROTOCOL       GraphicsOutput;
 188   EFI_GRAPHICS_OUTPUT_BLT_PIXEL      *GraphicsOutputBlt;
 189   EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  *GraphicsOutputModeBuffer;
 190   UINTN                              CurrentNumberOfGraphicsOutput;
 191   UINTN                              CurrentNumberOfUgaDraw;
 192   BOOLEAN                            HardwareNeedsStarting;
 193
 194   EFI_CONSOLE_CONTROL_PROTOCOL       ConsoleControl;
 195
 196   UINTN                              CurrentNumberOfConsoles;
 197   TEXT_OUT_AND_GOP_DATA              *TextOutList;
 198   UINTN                              TextOutListCount;
 199   TEXT_OUT_SPLITTER_QUERY_DATA       *TextOutQueryData;
 200   UINTN                              TextOutQueryDataCount;
 201   INT32                              *TextOutModeMap;
 202
 203   EFI_CONSOLE_CONTROL_SCREEN_MODE    ConsoleOutputMode;
 204
 205   UINTN                              DevNullColumns;
 206   UINTN                              DevNullRows;
 207   CHAR16                             *DevNullScreen;
 208   INT32                              *DevNullAttributes;
 209
 210 } TEXT_OUT_SPLITTER_PRIVATE_DATA;
 211
 212 #define TEXT_OUT_SPLITTER_PRIVATE_DATA_FROM_THIS(a) \
 213   CR ((a),                                            \
 214       TEXT_OUT_SPLITTER_PRIVATE_DATA,               \
 215       TextOut,                                      \
 216       TEXT_OUT_SPLITTER_PRIVATE_DATA_SIGNATURE      \
 217       )
 218
 219 #define GRAPHICS_OUTPUT_SPLITTER_PRIVATE_DATA_FROM_THIS(a)  \
 220   CR ((a),                                                    \
 221       TEXT_OUT_SPLITTER_PRIVATE_DATA,                       \
 222       GraphicsOutput,                                       \
 223       TEXT_OUT_SPLITTER_PRIVATE_DATA_SIGNATURE              \
 224       )
 225
 226 #define UGA_DRAW_SPLITTER_PRIVATE_DATA_FROM_THIS(a) \
 227   CR ((a),                                            \
 228       TEXT_OUT_SPLITTER_PRIVATE_DATA,               \
 229       UgaDraw,                                      \
 230       TEXT_OUT_SPLITTER_PRIVATE_DATA_SIGNATURE      \
 231       )
 232
 233 #define CONSOLE_CONTROL_SPLITTER_PRIVATE_DATA_FROM_THIS(a)  \
 234   CR ((a),                                                    \
 235       TEXT_OUT_SPLITTER_PRIVATE_DATA,                       \
 236       ConsoleControl,                                       \
 237       TEXT_OUT_SPLITTER_PRIVATE_DATA_SIGNATURE              \
 238       )
 239
 240 //
 241 // Function Prototypes
 242 //
 243 EFI_STATUS
 244 EFIAPI
 245 ConSplitterDriverEntry (
 246   IN EFI_HANDLE                       ImageHandle,
 247   IN EFI_SYSTEM_TABLE                 *SystemTable
 248   )
 249 ;
 250
 251 EFI_STATUS
 252 ConSplitterTextInConstructor (
 253   TEXT_IN_SPLITTER_PRIVATE_DATA       *Private
 254   )
 255 ;
 256
 257 EFI_STATUS
 258 ConSplitterTextOutConstructor (
 259   TEXT_OUT_SPLITTER_PRIVATE_DATA      *Private
 260   )
 261 ;
 262
 263 //
 264 // Driver Binding Functions
 265 //
 266 EFI_STATUS
 267 EFIAPI
 268 ConSplitterConInDriverBindingSupported (
 269   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 270   IN  EFI_HANDLE                      ControllerHandle,
 271   IN  EFI_DEVICE_PATH_PROTOCOL        *RemainingDevicePath
 272   )
 273 ;
 274
 275 EFI_STATUS
 276 EFIAPI
 277 ConSplitterSimplePointerDriverBindingSupported (
 278   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 279   IN  EFI_HANDLE                      ControllerHandle,
 280   IN  EFI_DEVICE_PATH_PROTOCOL        *RemainingDevicePath
 281   )
 282 ;
 283
 284 EFI_STATUS
 285 EFIAPI
 286 ConSplitterConOutDriverBindingSupported (
 287   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 288   IN  EFI_HANDLE                      ControllerHandle,
 289   IN  EFI_DEVICE_PATH_PROTOCOL        *RemainingDevicePath
 290   )
 291 ;
 292
 293 EFI_STATUS
 294 EFIAPI
 295 ConSplitterStdErrDriverBindingSupported (
 296   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 297   IN  EFI_HANDLE                      ControllerHandle,
 298   IN  EFI_DEVICE_PATH_PROTOCOL        *RemainingDevicePath
 299   )
 300 ;
 301
 302 EFI_STATUS
 303 EFIAPI
 304 ConSplitterConInDriverBindingStart (
 305   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 306   IN  EFI_HANDLE                      ControllerHandle,
 307   IN  EFI_DEVICE_PATH_PROTOCOL        *RemainingDevicePath
 308   )
 309 ;
 310
 311 EFI_STATUS
 312 EFIAPI
 313 ConSplitterSimplePointerDriverBindingStart (
 314   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 315   IN  EFI_HANDLE                      ControllerHandle,
 316   IN  EFI_DEVICE_PATH_PROTOCOL        *RemainingDevicePath
 317   )
 318 ;
 319
 320 EFI_STATUS
 321 EFIAPI
 322 ConSplitterConOutDriverBindingStart (
 323   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 324   IN  EFI_HANDLE                      ControllerHandle,
 325   IN  EFI_DEVICE_PATH_PROTOCOL        *RemainingDevicePath
 326   )
 327 ;
 328
 329 EFI_STATUS
 330 EFIAPI
 331 ConSplitterStdErrDriverBindingStart (
 332   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 333   IN  EFI_HANDLE                      ControllerHandle,
 334   IN  EFI_DEVICE_PATH_PROTOCOL        *RemainingDevicePath
 335   )
 336 ;
 337
 338 EFI_STATUS
 339 EFIAPI
 340 ConSplitterConInDriverBindingStop (
 341   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 342   IN  EFI_HANDLE                      ControllerHandle,
 343   IN  UINTN                           NumberOfChildren,
 344   IN  EFI_HANDLE                      *ChildHandleBuffer
 345   )
 346 ;
 347
 348 EFI_STATUS
 349 EFIAPI
 350 ConSplitterSimplePointerDriverBindingStop (
 351   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 352   IN  EFI_HANDLE                      ControllerHandle,
 353   IN  UINTN                           NumberOfChildren,
 354   IN  EFI_HANDLE                      *ChildHandleBuffer
 355   )
 356 ;
 357
 358 EFI_STATUS
 359 EFIAPI
 360 ConSplitterConOutDriverBindingStop (
 361   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 362   IN  EFI_HANDLE                      ControllerHandle,
 363   IN  UINTN                           NumberOfChildren,
 364   IN  EFI_HANDLE                      *ChildHandleBuffer
 365   )
 366 ;
 367
 368 EFI_STATUS
 369 EFIAPI
 370 ConSplitterStdErrDriverBindingStop (
 371   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 372   IN  EFI_HANDLE                      ControllerHandle,
 373   IN  UINTN                           NumberOfChildren,
 374   IN  EFI_HANDLE                      *ChildHandleBuffer
 375   )
 376 ;
 377
 378 //
 379 // Driver binding functions
 380 //
 381
 382 EFI_STATUS
 383 EFIAPI
 384 ConSplitterAbsolutePointerDriverBindingSupported (
 385   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 386   IN  EFI_HANDLE                      ControllerHandle,
 387   IN  EFI_DEVICE_PATH_PROTOCOL        *RemainingDevicePath
 388   )
 389 ;
 390
 391 EFI_STATUS
 392 EFIAPI
 393 ConSplitterAbsolutePointerDriverBindingStart (
 394   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 395   IN  EFI_HANDLE                      ControllerHandle,
 396   IN  EFI_DEVICE_PATH_PROTOCOL        *RemainingDevicePath
 397   )
 398 ;
 399
 400 EFI_STATUS
 401 EFIAPI
 402 ConSplitterAbsolutePointerDriverBindingStop (
 403   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 404   IN  EFI_HANDLE                      ControllerHandle,
 405   IN  UINTN                           NumberOfChildren,
 406   IN  EFI_HANDLE                      *ChildHandleBuffer
 407   )
 408 ;
 409
 410 EFI_STATUS
 411 ConSplitterAbsolutePointerAddDevice (
 412   IN  TEXT_IN_SPLITTER_PRIVATE_DATA     *Private,
 413   IN  EFI_ABSOLUTE_POINTER_PROTOCOL     *AbsolutePointer
 414   )
 415 ;
 416
 417 EFI_STATUS
 418 ConSplitterAbsolutePointerDeleteDevice (
 419   IN  TEXT_IN_SPLITTER_PRIVATE_DATA     *Private,
 420   IN  EFI_ABSOLUTE_POINTER_PROTOCOL     *AbsolutePointer
 421   )
 422 ;
 423
 424 //
 425 // Absolute Pointer protocol interfaces
 426 //
 427
 428 EFI_STATUS
 429 EFIAPI
 430 ConSplitterAbsolutePointerReset (
 431   IN EFI_ABSOLUTE_POINTER_PROTOCOL   *This,
 432   IN BOOLEAN                         ExtendedVerification
 433   )
 434 /*++
 435
 436   Routine Description:
 437     Resets the pointer device hardware.
 438
 439   Arguments:
 440     This                  - Protocol instance pointer.
 441     ExtendedVerification  - Driver may perform diagnostics on reset.
 442
 443   Returns:
 444     EFI_SUCCESS           - The device was reset.
 445     EFI_DEVICE_ERROR      - The device is not functioning correctly and could
 446                             not be reset.
 447
 448 --*/
 449 ;
 450
 451 EFI_STATUS
 452 EFIAPI
 453 ConSplitterAbsolutePointerGetState (
 454   IN EFI_ABSOLUTE_POINTER_PROTOCOL   *This,
 455   IN OUT EFI_ABSOLUTE_POINTER_STATE  *State
 456   )
 457 /*++
 458
 459   Routine Description:
 460     Retrieves the current state of a pointer device.
 461
 462   Arguments:
 463     This                  - Protocol instance pointer.
 464     State                 - A pointer to the state information on the pointer device.
 465
 466   Returns:
 467     EFI_SUCCESS           - The state of the pointer device was returned in State..
 468     EFI_NOT_READY         - The state of the pointer device has not changed since the last call to
 469                             GetState().
 470     EFI_DEVICE_ERROR      - A device error occurred while attempting to retrieve the pointer
 471                             device's current state.
 472 --*/
 473 ;
 474
 475 VOID
 476 EFIAPI
 477 ConSplitterAbsolutePointerWaitForInput (
 478   IN  EFI_EVENT                       Event,
 479   IN  VOID                            *Context
 480   )
 481 ;
 482
 483 /**
 484   Retrieves a Unicode string that is the user readable name of the driver.
 485
 486   This function retrieves the user readable name of a driver in the form of a
 487   Unicode string. If the driver specified by This has a user readable name in
 488   the language specified by Language, then a pointer to the driver name is
 489   returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
 490   by This does not support the language specified by Language,
 491   then EFI_UNSUPPORTED is returned.
 492
 493   @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
 494                                 EFI_COMPONENT_NAME_PROTOCOL instance.
 495
 496   @param  Language[in]          A pointer to a Null-terminated ASCII string
 497                                 array indicating the language. This is the
 498                                 language of the driver name that the caller is
 499                                 requesting, and it must match one of the
 500                                 languages specified in SupportedLanguages. The
 501                                 number of languages supported by a driver is up
 502                                 to the driver writer. Language is specified
 503                                 in RFC 3066 or ISO 639-2 language code format.
 504
 505   @param  DriverName[out]       A pointer to the Unicode string to return.
 506                                 This Unicode string is the name of the
 507                                 driver specified by This in the language
 508                                 specified by Language.
 509
 510   @retval EFI_SUCCESS           The Unicode string for the Driver specified by
 511                                 This and the language specified by Language was
 512                                 returned in DriverName.
 513
 514   @retval EFI_INVALID_PARAMETER Language is NULL.
 515
 516   @retval EFI_INVALID_PARAMETER DriverName is NULL.
 517
 518   @retval EFI_UNSUPPORTED       The driver specified by This does not support
 519                                 the language specified by Language.
 520
 521 **/
 522 EFI_STATUS
 523 EFIAPI
 524 ConSplitterComponentNameGetDriverName (
 525   IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
 526   IN  CHAR8                        *Language,
 527   OUT CHAR16                       **DriverName
 528   );
 529
 530
 531 /**
 532   Retrieves a Unicode string that is the user readable name of the controller
 533   that is being managed by a driver.
 534
 535   This function retrieves the user readable name of the controller specified by
 536   ControllerHandle and ChildHandle in the form of a Unicode string. If the
 537   driver specified by This has a user readable name in the language specified by
 538   Language, then a pointer to the controller name is returned in ControllerName,
 539   and EFI_SUCCESS is returned.  If the driver specified by This is not currently
 540   managing the controller specified by ControllerHandle and ChildHandle,
 541   then EFI_UNSUPPORTED is returned.  If the driver specified by This does not
 542   support the language specified by Language, then EFI_UNSUPPORTED is returned.
 543
 544   @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
 545                                 EFI_COMPONENT_NAME_PROTOCOL instance.
 546
 547   @param  ControllerHandle[in]  The handle of a controller that the driver
 548                                 specified by This is managing.  This handle
 549                                 specifies the controller whose name is to be
 550                                 returned.
 551
 552   @param  ChildHandle[in]       The handle of the child controller to retrieve
 553                                 the name of.  This is an optional parameter that
 554                                 may be NULL.  It will be NULL for device
 555                                 drivers.  It will also be NULL for a bus drivers
 556                                 that wish to retrieve the name of the bus
 557                                 controller.  It will not be NULL for a bus
 558                                 driver that wishes to retrieve the name of a
 559                                 child controller.
 560
 561   @param  Language[in]          A pointer to a Null-terminated ASCII string
 562                                 array indicating the language.  This is the
 563                                 language of the driver name that the caller is
 564                                 requesting, and it must match one of the
 565                                 languages specified in SupportedLanguages. The
 566                                 number of languages supported by a driver is up
 567                                 to the driver writer. Language is specified in
 568                                 RFC 3066 or ISO 639-2 language code format.
 569
 570   @param  ControllerName[out]   A pointer to the Unicode string to return.
 571                                 This Unicode string is the name of the
 572                                 controller specified by ControllerHandle and
 573                                 ChildHandle in the language specified by
 574                                 Language from the point of view of the driver
 575                                 specified by This.
 576
 577   @retval EFI_SUCCESS           The Unicode string for the user readable name in
 578                                 the language specified by Language for the
 579                                 driver specified by This was returned in
 580                                 DriverName.
 581
 582   @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
 583
 584   @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
 585                                 EFI_HANDLE.
 586
 587   @retval EFI_INVALID_PARAMETER Language is NULL.
 588
 589   @retval EFI_INVALID_PARAMETER ControllerName is NULL.
 590
 591   @retval EFI_UNSUPPORTED       The driver specified by This is not currently
 592                                 managing the controller specified by
 593                                 ControllerHandle and ChildHandle.
 594
 595   @retval EFI_UNSUPPORTED       The driver specified by This does not support
 596                                 the language specified by Language.
 597
 598 **/
 599 EFI_STATUS
 600 EFIAPI
 601 ConSplitterConInComponentNameGetControllerName (
 602   IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,
 603   IN  EFI_HANDLE                                      ControllerHandle,
 604   IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
 605   IN  CHAR8                                           *Language,
 606   OUT CHAR16                                          **ControllerName
 607   );
 608
 609
 610 /**
 611   Retrieves a Unicode string that is the user readable name of the controller
 612   that is being managed by a driver.
 613
 614   This function retrieves the user readable name of the controller specified by
 615   ControllerHandle and ChildHandle in the form of a Unicode string. If the
 616   driver specified by This has a user readable name in the language specified by
 617   Language, then a pointer to the controller name is returned in ControllerName,
 618   and EFI_SUCCESS is returned.  If the driver specified by This is not currently
 619   managing the controller specified by ControllerHandle and ChildHandle,
 620   then EFI_UNSUPPORTED is returned.  If the driver specified by This does not
 621   support the language specified by Language, then EFI_UNSUPPORTED is returned.
 622
 623   @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
 624                                 EFI_COMPONENT_NAME_PROTOCOL instance.
 625
 626   @param  ControllerHandle[in]  The handle of a controller that the driver
 627                                 specified by This is managing.  This handle
 628                                 specifies the controller whose name is to be
 629                                 returned.
 630
 631   @param  ChildHandle[in]       The handle of the child controller to retrieve
 632                                 the name of.  This is an optional parameter that
 633                                 may be NULL.  It will be NULL for device
 634                                 drivers.  It will also be NULL for a bus drivers
 635                                 that wish to retrieve the name of the bus
 636                                 controller.  It will not be NULL for a bus
 637                                 driver that wishes to retrieve the name of a
 638                                 child controller.
 639
 640   @param  Language[in]          A pointer to a Null-terminated ASCII string
 641                                 array indicating the language.  This is the
 642                                 language of the driver name that the caller is
 643                                 requesting, and it must match one of the
 644                                 languages specified in SupportedLanguages. The
 645                                 number of languages supported by a driver is up
 646                                 to the driver writer. Language is specified in
 647                                 RFC 3066 or ISO 639-2 language code format.
 648
 649   @param  ControllerName[out]   A pointer to the Unicode string to return.
 650                                 This Unicode string is the name of the
 651                                 controller specified by ControllerHandle and
 652                                 ChildHandle in the language specified by
 653                                 Language from the point of view of the driver
 654                                 specified by This.
 655
 656   @retval EFI_SUCCESS           The Unicode string for the user readable name in
 657                                 the language specified by Language for the
 658                                 driver specified by This was returned in
 659                                 DriverName.
 660
 661   @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
 662
 663   @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
 664                                 EFI_HANDLE.
 665
 666   @retval EFI_INVALID_PARAMETER Language is NULL.
 667
 668   @retval EFI_INVALID_PARAMETER ControllerName is NULL.
 669
 670   @retval EFI_UNSUPPORTED       The driver specified by This is not currently
 671                                 managing the controller specified by
 672                                 ControllerHandle and ChildHandle.
 673
 674   @retval EFI_UNSUPPORTED       The driver specified by This does not support
 675                                 the language specified by Language.
 676
 677 **/
 678 EFI_STATUS
 679 EFIAPI
 680 ConSplitterSimplePointerComponentNameGetControllerName (
 681   IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,
 682   IN  EFI_HANDLE                                      ControllerHandle,
 683   IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
 684   IN  CHAR8                                           *Language,
 685   OUT CHAR16                                          **ControllerName
 686   );
 687
 688 EFI_STATUS
 689 EFIAPI
 690 ConSplitterAbsolutePointerComponentNameGetControllerName (
 691   IN  EFI_COMPONENT_NAME_PROTOCOL                    *This,
 692   IN  EFI_HANDLE                                      ControllerHandle,
 693   IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
 694   IN  CHAR8                                           *Language,
 695   OUT CHAR16                                          **ControllerName
 696   )
 697 ;
 698
 699 /**
 700   Retrieves a Unicode string that is the user readable name of the controller
 701   that is being managed by a driver.
 702
 703   This function retrieves the user readable name of the controller specified by
 704   ControllerHandle and ChildHandle in the form of a Unicode string. If the
 705   driver specified by This has a user readable name in the language specified by
 706   Language, then a pointer to the controller name is returned in ControllerName,
 707   and EFI_SUCCESS is returned.  If the driver specified by This is not currently
 708   managing the controller specified by ControllerHandle and ChildHandle,
 709   then EFI_UNSUPPORTED is returned.  If the driver specified by This does not
 710   support the language specified by Language, then EFI_UNSUPPORTED is returned.
 711
 712   @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
 713                                 EFI_COMPONENT_NAME_PROTOCOL instance.
 714
 715   @param  ControllerHandle[in]  The handle of a controller that the driver
 716                                 specified by This is managing.  This handle
 717                                 specifies the controller whose name is to be
 718                                 returned.
 719
 720   @param  ChildHandle[in]       The handle of the child controller to retrieve
 721                                 the name of.  This is an optional parameter that
 722                                 may be NULL.  It will be NULL for device
 723                                 drivers.  It will also be NULL for a bus drivers
 724                                 that wish to retrieve the name of the bus
 725                                 controller.  It will not be NULL for a bus
 726                                 driver that wishes to retrieve the name of a
 727                                 child controller.
 728
 729   @param  Language[in]          A pointer to a Null-terminated ASCII string
 730                                 array indicating the language.  This is the
 731                                 language of the driver name that the caller is
 732                                 requesting, and it must match one of the
 733                                 languages specified in SupportedLanguages. The
 734                                 number of languages supported by a driver is up
 735                                 to the driver writer. Language is specified in
 736                                 RFC 3066 or ISO 639-2 language code format.
 737
 738   @param  ControllerName[out]   A pointer to the Unicode string to return.
 739                                 This Unicode string is the name of the
 740                                 controller specified by ControllerHandle and
 741                                 ChildHandle in the language specified by
 742                                 Language from the point of view of the driver
 743                                 specified by This.
 744
 745   @retval EFI_SUCCESS           The Unicode string for the user readable name in
 746                                 the language specified by Language for the
 747                                 driver specified by This was returned in
 748                                 DriverName.
 749
 750   @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
 751
 752   @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
 753                                 EFI_HANDLE.
 754
 755   @retval EFI_INVALID_PARAMETER Language is NULL.
 756
 757   @retval EFI_INVALID_PARAMETER ControllerName is NULL.
 758
 759   @retval EFI_UNSUPPORTED       The driver specified by This is not currently
 760                                 managing the controller specified by
 761                                 ControllerHandle and ChildHandle.
 762
 763   @retval EFI_UNSUPPORTED       The driver specified by This does not support
 764                                 the language specified by Language.
 765
 766 **/
 767 EFI_STATUS
 768 EFIAPI
 769 ConSplitterConOutComponentNameGetControllerName (
 770   IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,
 771   IN  EFI_HANDLE                                      ControllerHandle,
 772   IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
 773   IN  CHAR8                                           *Language,
 774   OUT CHAR16                                          **ControllerName
 775   );
 776
 777
 778 /**
 779   Retrieves a Unicode string that is the user readable name of the controller
 780   that is being managed by a driver.
 781
 782   This function retrieves the user readable name of the controller specified by
 783   ControllerHandle and ChildHandle in the form of a Unicode string. If the
 784   driver specified by This has a user readable name in the language specified by
 785   Language, then a pointer to the controller name is returned in ControllerName,
 786   and EFI_SUCCESS is returned.  If the driver specified by This is not currently
 787   managing the controller specified by ControllerHandle and ChildHandle,
 788   then EFI_UNSUPPORTED is returned.  If the driver specified by This does not
 789   support the language specified by Language, then EFI_UNSUPPORTED is returned.
 790
 791   @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
 792                                 EFI_COMPONENT_NAME_PROTOCOL instance.
 793
 794   @param  ControllerHandle[in]  The handle of a controller that the driver
 795                                 specified by This is managing.  This handle
 796                                 specifies the controller whose name is to be
 797                                 returned.
 798
 799   @param  ChildHandle[in]       The handle of the child controller to retrieve
 800                                 the name of.  This is an optional parameter that
 801                                 may be NULL.  It will be NULL for device
 802                                 drivers.  It will also be NULL for a bus drivers
 803                                 that wish to retrieve the name of the bus
 804                                 controller.  It will not be NULL for a bus
 805                                 driver that wishes to retrieve the name of a
 806                                 child controller.
 807
 808   @param  Language[in]          A pointer to a Null-terminated ASCII string
 809                                 array indicating the language.  This is the
 810                                 language of the driver name that the caller is
 811                                 requesting, and it must match one of the
 812                                 languages specified in SupportedLanguages. The
 813                                 number of languages supported by a driver is up
 814                                 to the driver writer. Language is specified in
 815                                 RFC 3066 or ISO 639-2 language code format.
 816
 817   @param  ControllerName[out]   A pointer to the Unicode string to return.
 818                                 This Unicode string is the name of the
 819                                 controller specified by ControllerHandle and
 820                                 ChildHandle in the language specified by
 821                                 Language from the point of view of the driver
 822                                 specified by This.
 823
 824   @retval EFI_SUCCESS           The Unicode string for the user readable name in
 825                                 the language specified by Language for the
 826                                 driver specified by This was returned in
 827                                 DriverName.
 828
 829   @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
 830
 831   @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
 832                                 EFI_HANDLE.
 833
 834   @retval EFI_INVALID_PARAMETER Language is NULL.
 835
 836   @retval EFI_INVALID_PARAMETER ControllerName is NULL.
 837
 838   @retval EFI_UNSUPPORTED       The driver specified by This is not currently
 839                                 managing the controller specified by
 840                                 ControllerHandle and ChildHandle.
 841
 842   @retval EFI_UNSUPPORTED       The driver specified by This does not support
 843                                 the language specified by Language.
 844
 845 **/
 846 EFI_STATUS
 847 EFIAPI
 848 ConSplitterStdErrComponentNameGetControllerName (
 849   IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,
 850   IN  EFI_HANDLE                                      ControllerHandle,
 851   IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
 852   IN  CHAR8                                           *Language,
 853   OUT CHAR16                                          **ControllerName
 854   );
 855
 856
 857 //
 858 // TextIn Constructor/Destructor functions
 859 //
 860 EFI_STATUS
 861 ConSplitterTextInAddDevice (
 862   IN  TEXT_IN_SPLITTER_PRIVATE_DATA      *Private,
 863   IN  EFI_SIMPLE_TEXT_INPUT_PROTOCOL     *TextIn
 864   )
 865 ;
 866
 867 EFI_STATUS
 868 ConSplitterTextInDeleteDevice (
 869   IN  TEXT_IN_SPLITTER_PRIVATE_DATA      *Private,
 870   IN  EFI_SIMPLE_TEXT_INPUT_PROTOCOL     *TextIn
 871   )
 872 ;
 873
 874 //
 875 // SimplePointer Constuctor/Destructor functions
 876 //
 877 EFI_STATUS
 878 ConSplitterSimplePointerAddDevice (
 879   IN  TEXT_IN_SPLITTER_PRIVATE_DATA   *Private,
 880   IN  EFI_SIMPLE_POINTER_PROTOCOL     *SimplePointer
 881   )
 882 ;
 883
 884 EFI_STATUS
 885 ConSplitterSimplePointerDeleteDevice (
 886   IN  TEXT_IN_SPLITTER_PRIVATE_DATA   *Private,
 887   IN  EFI_SIMPLE_POINTER_PROTOCOL     *SimplePointer
 888   )
 889 ;
 890
 891 //
 892 // TextOut Constuctor/Destructor functions
 893 //
 894 EFI_STATUS
 895 ConSplitterTextOutAddDevice (
 896   IN  TEXT_OUT_SPLITTER_PRIVATE_DATA     *Private,
 897   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    *TextOut,
 898   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL       *GraphicsOutput,
 899   IN  EFI_UGA_DRAW_PROTOCOL              *UgaDraw
 900   )
 901 ;
 902
 903 EFI_STATUS
 904 ConSplitterTextOutDeleteDevice (
 905   IN  TEXT_OUT_SPLITTER_PRIVATE_DATA     *Private,
 906   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    *TextOut
 907   )
 908 ;
 909
 910 //
 911 // TextIn I/O Functions
 912 //
 913 EFI_STATUS
 914 EFIAPI
 915 ConSplitterTextInReset (
 916   IN  EFI_SIMPLE_TEXT_INPUT_PROTOCOL     *This,
 917   IN  BOOLEAN                            ExtendedVerification
 918   )
 919 ;
 920
 921 EFI_STATUS
 922 EFIAPI
 923 ConSplitterTextInReadKeyStroke (
 924   IN  EFI_SIMPLE_TEXT_INPUT_PROTOCOL     *This,
 925   OUT EFI_INPUT_KEY                      *Key
 926   )
 927 ;
 928 EFI_STATUS
 929 ConSplitterTextInExAddDevice (
 930   IN  TEXT_IN_SPLITTER_PRIVATE_DATA         *Private,
 931   IN  EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL     *TextInEx
 932   )
 933 ;
 934
 935 EFI_STATUS
 936 ConSplitterTextInExDeleteDevice (
 937   IN  TEXT_IN_SPLITTER_PRIVATE_DATA         *Private,
 938   IN  EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL     *TextInEx
 939   )
 940 ;
 941
 942 //
 943 // Simple Text Input Ex protocol function prototypes
 944 //
 945
 946 EFI_STATUS
 947 EFIAPI
 948 ConSplitterTextInResetEx (
 949   IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
 950   IN BOOLEAN                            ExtendedVerification
 951   )
 952 /*++
 953
 954   Routine Description:
 955     Reset the input device and optionaly run diagnostics
 956
 957   Arguments:
 958     This                 - Protocol instance pointer.
 959     ExtendedVerification - Driver may perform diagnostics on reset.
 960
 961   Returns:
 962     EFI_SUCCESS           - The device was reset.
 963     EFI_DEVICE_ERROR      - The device is not functioning properly and could
 964                             not be reset.
 965
 966 --*/
 967 ;
 968
 969 EFI_STATUS
 970 EFIAPI
 971 ConSplitterTextInReadKeyStrokeEx (
 972   IN  EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
 973   OUT EFI_KEY_DATA                      *KeyData
 974   )
 975 /*++
 976
 977   Routine Description:
 978     Reads the next keystroke from the input device. The WaitForKey Event can
 979     be used to test for existance of a keystroke via WaitForEvent () call.
 980
 981   Arguments:
 982     This       - Protocol instance pointer.
 983     KeyData    - A pointer to a buffer that is filled in with the keystroke
 984                  state data for the key that was pressed.
 985
 986   Returns:
 987     EFI_SUCCESS           - The keystroke information was returned.
 988     EFI_NOT_READY         - There was no keystroke data availiable.
 989     EFI_DEVICE_ERROR      - The keystroke information was not returned due to
 990                             hardware errors.
 991     EFI_INVALID_PARAMETER - KeyData is NULL.
 992
 993 --*/
 994 ;
 995
 996 EFI_STATUS
 997 EFIAPI
 998 ConSplitterTextInSetState (
 999   IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
1000   IN EFI_KEY_TOGGLE_STATE               *KeyToggleState
1001   )
1002 /*++
1003
1004   Routine Description:
1005     Set certain state for the input device.
1006
1007   Arguments:
1008     This                  - Protocol instance pointer.
1009     KeyToggleState        - A pointer to the EFI_KEY_TOGGLE_STATE to set the
1010                             state for the input device.
1011
1012   Returns:
1013     EFI_SUCCESS           - The device state was set successfully.
1014     EFI_DEVICE_ERROR      - The device is not functioning correctly and could
1015                             not have the setting adjusted.
1016     EFI_UNSUPPORTED       - The device does not have the ability to set its state.
1017     EFI_INVALID_PARAMETER - KeyToggleState is NULL.
1018
1019 --*/
1020 ;
1021
1022 EFI_STATUS
1023 EFIAPI
1024 ConSplitterTextInRegisterKeyNotify (
1025   IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
1026   IN EFI_KEY_DATA                       *KeyData,
1027   IN EFI_KEY_NOTIFY_FUNCTION            KeyNotificationFunction,
1028   OUT EFI_HANDLE                        *NotifyHandle
1029   )
1030 /*++
1031
1032   Routine Description:
1033     Register a notification function for a particular keystroke for the input device.
1034
1035   Arguments:
1036     This                    - Protocol instance pointer.
1037     KeyData                 - A pointer to a buffer that is filled in with the keystroke
1038                               information data for the key that was pressed.
1039     KeyNotificationFunction - Points to the function to be called when the key
1040                               sequence is typed specified by KeyData.
1041     NotifyHandle            - Points to the unique handle assigned to the registered notification.
1042
1043   Returns:
1044     EFI_SUCCESS             - The notification function was registered successfully.
1045     EFI_OUT_OF_RESOURCES    - Unable to allocate resources for necesssary data structures.
1046     EFI_INVALID_PARAMETER   - KeyData or NotifyHandle is NULL.
1047
1048 --*/
1049 ;
1050
1051 EFI_STATUS
1052 EFIAPI
1053 ConSplitterTextInUnregisterKeyNotify (
1054   IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
1055   IN EFI_HANDLE                         NotificationHandle
1056   )
1057 /*++
1058
1059   Routine Description:
1060     Remove a registered notification function from a particular keystroke.
1061
1062   Arguments:
1063     This                    - Protocol instance pointer.
1064     NotificationHandle      - The handle of the notification function being unregistered.
1065
1066   Returns:
1067     EFI_SUCCESS             - The notification function was unregistered successfully.
1068     EFI_INVALID_PARAMETER   - The NotificationHandle is invalid.
1069     EFI_NOT_FOUND           - Can not find the matching entry in database.
1070
1071 --*/
1072 ;
1073 VOID
1074 EFIAPI
1075 ConSplitterTextInWaitForKey (
1076   IN  EFI_EVENT                       Event,
1077   IN  VOID                            *Context
1078   )
1079 ;
1080
1081 BOOLEAN
1082 ConSpliterConssoleControlStdInLocked (
1083   VOID
1084   )
1085 ;
1086
1087 VOID
1088 EFIAPI
1089 ConSpliterConsoleControlLockStdInEvent (
1090   IN  EFI_EVENT                       Event,
1091   IN  VOID                            *Context
1092   )
1093 ;
1094
1095 EFI_STATUS
1096 EFIAPI
1097 ConSpliterConsoleControlLockStdIn (
1098   IN  EFI_CONSOLE_CONTROL_PROTOCOL    *This,
1099   IN  CHAR16                          *Password
1100   )
1101 ;
1102
1103 EFI_STATUS
1104 EFIAPI
1105 ConSplitterTextInPrivateReadKeyStroke (
1106   IN  TEXT_IN_SPLITTER_PRIVATE_DATA   *Private,
1107   OUT EFI_INPUT_KEY                   *Key
1108   )
1109 ;
1110
1111 EFI_STATUS
1112 EFIAPI
1113 ConSplitterSimplePointerReset (
1114   IN  EFI_SIMPLE_POINTER_PROTOCOL     *This,
1115   IN  BOOLEAN                         ExtendedVerification
1116   )
1117 ;
1118
1119 EFI_STATUS
1120 EFIAPI
1121 ConSplitterSimplePointerGetState (
1122   IN  EFI_SIMPLE_POINTER_PROTOCOL     *This,
1123   IN OUT EFI_SIMPLE_POINTER_STATE     *State
1124   )
1125 ;
1126
1127 VOID
1128 EFIAPI
1129 ConSplitterSimplePointerWaitForInput (
1130   IN  EFI_EVENT                       Event,
1131   IN  VOID                            *Context
1132   )
1133 ;
1134
1135 //
1136 // TextOut I/O Functions
1137 //
1138 VOID
1139 ConSplitterSynchronizeModeData (
1140   TEXT_OUT_SPLITTER_PRIVATE_DATA      *Private
1141   )
1142 ;
1143
1144 EFI_STATUS
1145 EFIAPI
1146 ConSplitterTextOutReset (
1147   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    *This,
1148   IN  BOOLEAN                            ExtendedVerification
1149   )
1150 ;
1151
1152 EFI_STATUS
1153 EFIAPI
1154 ConSplitterTextOutOutputString (
1155   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    *This,
1156   IN  CHAR16                             *WString
1157   )
1158 ;
1159
1160 EFI_STATUS
1161 EFIAPI
1162 ConSplitterTextOutTestString (
1163   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    *This,
1164   IN  CHAR16                             *WString
1165   )
1166 ;
1167
1168 EFI_STATUS
1169 EFIAPI
1170 ConSplitterTextOutQueryMode (
1171   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    *This,
1172   IN  UINTN                              ModeNumber,
1173   OUT UINTN                              *Columns,
1174   OUT UINTN                              *Rows
1175   )
1176 ;
1177
1178 EFI_STATUS
1179 EFIAPI
1180 ConSplitterTextOutSetMode (
1181   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    *This,
1182   IN  UINTN                              ModeNumber
1183   )
1184 ;
1185
1186 EFI_STATUS
1187 EFIAPI
1188 ConSplitterTextOutSetAttribute (
1189   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    *This,
1190   IN  UINTN                              Attribute
1191   )
1192 ;
1193
1194 EFI_STATUS
1195 EFIAPI
1196 ConSplitterTextOutClearScreen (
1197   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    *This
1198   )
1199 ;
1200
1201 EFI_STATUS
1202 EFIAPI
1203 ConSplitterTextOutSetCursorPosition (
1204   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    *This,
1205   IN  UINTN                              Column,
1206   IN  UINTN                              Row
1207   )
1208 ;
1209
1210 EFI_STATUS
1211 EFIAPI
1212 ConSplitterTextOutEnableCursor (
1213   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    *This,
1214   IN  BOOLEAN                            Visible
1215   )
1216 ;
1217
1218 EFI_STATUS
1219 ConSplitterGrowBuffer (
1220   IN  UINTN                           SizeOfCount,
1221   IN  UINTN                           *Count,
1222   IN OUT  VOID                        **Buffer
1223   )
1224 ;
1225
1226 EFI_STATUS
1227 EFIAPI
1228 ConSpliterConsoleControlGetMode (
1229   IN  EFI_CONSOLE_CONTROL_PROTOCOL    *This,
1230   OUT EFI_CONSOLE_CONTROL_SCREEN_MODE *Mode,
1231   OUT BOOLEAN                         *GopExists,
1232   OUT BOOLEAN                         *StdInLocked
1233   )
1234 ;
1235
1236 EFI_STATUS
1237 EFIAPI
1238 ConSpliterConsoleControlSetMode (
1239   IN  EFI_CONSOLE_CONTROL_PROTOCOL    *This,
1240   IN  EFI_CONSOLE_CONTROL_SCREEN_MODE Mode
1241   )
1242 ;
1243
1244 EFI_STATUS
1245 EFIAPI
1246 ConSpliterGraphicsOutputQueryMode (
1247   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL        *This,
1248   IN  UINT32                            ModeNumber,
1249   OUT UINTN                              *SizeOfInfo,
1250   OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  **Info
1251   )
1252 ;
1253
1254 EFI_STATUS
1255 EFIAPI
1256 ConSpliterGraphicsOutputSetMode (
1257   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL * This,
1258   IN  UINT32                       ModeNumber
1259   )
1260 ;
1261
1262 EFI_STATUS
1263 EFIAPI
1264 ConSpliterGraphicsOutputBlt (
1265   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL                  *This,
1266   IN  EFI_GRAPHICS_OUTPUT_BLT_PIXEL                 *BltBuffer, OPTIONAL
1267   IN  EFI_GRAPHICS_OUTPUT_BLT_OPERATION             BltOperation,
1268   IN  UINTN                                         SourceX,
1269   IN  UINTN                                         SourceY,
1270   IN  UINTN                                         DestinationX,
1271   IN  UINTN                                         DestinationY,
1272   IN  UINTN                                         Width,
1273   IN  UINTN                                         Height,
1274   IN  UINTN                                         Delta         OPTIONAL
1275   )
1276 ;
1277
1278 EFI_STATUS
1279 DevNullGopSync (
1280   IN  TEXT_OUT_SPLITTER_PRIVATE_DATA  *Private,
1281   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL    *GraphicsOutput,
1282   IN  EFI_UGA_DRAW_PROTOCOL           *UgaDraw
1283   )
1284 ;
1285
1286 EFI_STATUS
1287 EFIAPI
1288 ConSpliterUgaDrawGetMode (
1289   IN  EFI_UGA_DRAW_PROTOCOL           *This,
1290   OUT UINT32                          *HorizontalResolution,
1291   OUT UINT32                          *VerticalResolution,
1292   OUT UINT32                          *ColorDepth,
1293   OUT UINT32                          *RefreshRate
1294   )
1295 ;
1296
1297 EFI_STATUS
1298 EFIAPI
1299 ConSpliterUgaDrawSetMode (
1300   IN  EFI_UGA_DRAW_PROTOCOL           *This,
1301   IN UINT32                           HorizontalResolution,
1302   IN UINT32                           VerticalResolution,
1303   IN UINT32                           ColorDepth,
1304   IN UINT32                           RefreshRate
1305   )
1306 ;
1307
1308 EFI_STATUS
1309 EFIAPI
1310 ConSpliterUgaDrawBlt (
1311   IN  EFI_UGA_DRAW_PROTOCOL                         *This,
1312   IN  EFI_UGA_PIXEL                                 *BltBuffer, OPTIONAL
1313   IN  EFI_UGA_BLT_OPERATION                         BltOperation,
1314   IN  UINTN                                         SourceX,
1315   IN  UINTN                                         SourceY,
1316   IN  UINTN                                         DestinationX,
1317   IN  UINTN                                         DestinationY,
1318   IN  UINTN                                         Width,
1319   IN  UINTN                                         Height,
1320   IN  UINTN                                         Delta         OPTIONAL
1321   )
1322 ;
1323
1324 EFI_STATUS
1325 DevNullUgaSync (
1326   IN  TEXT_OUT_SPLITTER_PRIVATE_DATA  *Private,
1327   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL    *GraphicsOutput,
1328   IN  EFI_UGA_DRAW_PROTOCOL           *UgaDraw
1329   )
1330 ;
1331
1332 EFI_STATUS
1333 DevNullTextOutOutputString (
1334   IN  TEXT_OUT_SPLITTER_PRIVATE_DATA  *Private,
1335   IN  CHAR16                          *WString
1336   )
1337 ;
1338
1339 EFI_STATUS
1340 DevNullTextOutSetMode (
1341   IN  TEXT_OUT_SPLITTER_PRIVATE_DATA  *Private,
1342   IN  UINTN                           ModeNumber
1343   )
1344 ;
1345
1346 EFI_STATUS
1347 DevNullTextOutClearScreen (
1348   IN  TEXT_OUT_SPLITTER_PRIVATE_DATA  *Private
1349   )
1350 ;
1351
1352 EFI_STATUS
1353 DevNullTextOutSetCursorPosition (
1354   IN  TEXT_OUT_SPLITTER_PRIVATE_DATA  *Private,
1355   IN  UINTN                           Column,
1356   IN  UINTN                           Row
1357   )
1358 ;
1359
1360 EFI_STATUS
1361 DevNullTextOutEnableCursor (
1362   IN  TEXT_OUT_SPLITTER_PRIVATE_DATA  *Private,
1363   IN  BOOLEAN                         Visible
1364   )
1365 ;
1366
1367 EFI_STATUS
1368 DevNullSyncStdOut (
1369   IN  TEXT_OUT_SPLITTER_PRIVATE_DATA  *Private
1370   )
1371 ;
1372
1373 #endif