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