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