]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - MdeModulePkg/Universal/Console/ConSplitterDxe/ConSplitter.c
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Retire Extended HII library class.
[mirror_edk2.git] / MdeModulePkg / Universal / Console / ConSplitterDxe / ConSplitter.c
... / ...
CommitLineData
1/** @file\r
2 Console Splitter Driver. Any Handle that attatched console I/O protocols\r
3 (Console In device, Console Out device, Console Error device, Simple Pointer\r
4 protocol, Absolute Pointer protocol) can be bound by this driver.\r
5\r
6 So far it works like any other driver by opening a SimpleTextIn and/or\r
7 SimpleTextOut protocol with EFI_OPEN_PROTOCOL_BY_DRIVER attributes. The big\r
8 difference is this driver does not layer a protocol on the passed in\r
9 handle, or construct a child handle like a standard device or bus driver.\r
10 This driver produces three virtual handles as children, one for console input\r
11 splitter, one for console output splitter and one for error output splitter.\r
12 These 3 virtual handles would be installed on gST.\r
13\r
14 Each virtual handle, that supports the Console I/O protocol, will be produced\r
15 in the driver entry point. The virtual handle are added on driver entry and\r
16 never removed. Such design ensures sytem function well during none console\r
17 device situation.\r
18\r
19Copyright (c) 2006 - 2009, Intel Corporation. <BR>\r
20All rights reserved. This program and the accompanying materials\r
21are licensed and made available under the terms and conditions of the BSD License\r
22which accompanies this distribution. The full text of the license may be found at\r
23http://opensource.org/licenses/bsd-license.php\r
24\r
25THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
26WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
27\r
28**/\r
29\r
30#include "ConSplitter.h"\r
31\r
32//\r
33// Text In Splitter Private Data template\r
34//\r
35GLOBAL_REMOVE_IF_UNREFERENCED TEXT_IN_SPLITTER_PRIVATE_DATA mConIn = {\r
36 TEXT_IN_SPLITTER_PRIVATE_DATA_SIGNATURE,\r
37 (EFI_HANDLE) NULL,\r
38\r
39 {\r
40 ConSplitterTextInReset,\r
41 ConSplitterTextInReadKeyStroke,\r
42 (EFI_EVENT) NULL\r
43 },\r
44 0,\r
45 (EFI_SIMPLE_TEXT_INPUT_PROTOCOL **) NULL,\r
46 0,\r
47\r
48 {\r
49 ConSplitterTextInResetEx,\r
50 ConSplitterTextInReadKeyStrokeEx,\r
51 (EFI_EVENT) NULL,\r
52 ConSplitterTextInSetState,\r
53 ConSplitterTextInRegisterKeyNotify,\r
54 ConSplitterTextInUnregisterKeyNotify\r
55 },\r
56 0,\r
57 (EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL **) NULL,\r
58 0,\r
59 {\r
60 (LIST_ENTRY *) NULL,\r
61 (LIST_ENTRY *) NULL\r
62 },\r
63\r
64 {\r
65 ConSplitterSimplePointerReset,\r
66 ConSplitterSimplePointerGetState,\r
67 (EFI_EVENT) NULL,\r
68 (EFI_SIMPLE_POINTER_MODE *) NULL\r
69 },\r
70 {\r
71 0x10000,\r
72 0x10000,\r
73 0x10000,\r
74 TRUE,\r
75 TRUE\r
76 },\r
77 0,\r
78 (EFI_SIMPLE_POINTER_PROTOCOL **) NULL,\r
79 0,\r
80\r
81 {\r
82 ConSplitterAbsolutePointerReset,\r
83 ConSplitterAbsolutePointerGetState,\r
84 (EFI_EVENT) NULL,\r
85 (EFI_ABSOLUTE_POINTER_MODE *) NULL\r
86 },\r
87 {\r
88 0, // AbsoluteMinX\r
89 0, // AbsoluteMinY\r
90 0, // AbsoluteMinZ\r
91 0x10000, // AbsoluteMaxX\r
92 0x10000, // AbsoluteMaxY\r
93 0x10000, // AbsoluteMaxZ\r
94 0 // Attributes\r
95 },\r
96 0,\r
97 (EFI_ABSOLUTE_POINTER_PROTOCOL **) NULL,\r
98 0,\r
99 FALSE,\r
100\r
101 FALSE,\r
102 FALSE\r
103};\r
104\r
105\r
106//\r
107// Uga Draw Protocol Private Data template\r
108//\r
109GLOBAL_REMOVE_IF_UNREFERENCED EFI_UGA_DRAW_PROTOCOL mUgaDrawProtocolTemplate = {\r
110 ConSpliterUgaDrawGetMode,\r
111 ConSpliterUgaDrawSetMode,\r
112 ConSpliterUgaDrawBlt\r
113};\r
114\r
115//\r
116// Graphics Output Protocol Private Data template\r
117//\r
118GLOBAL_REMOVE_IF_UNREFERENCED EFI_GRAPHICS_OUTPUT_PROTOCOL mGraphicsOutputProtocolTemplate = {\r
119 ConSpliterGraphicsOutputQueryMode,\r
120 ConSpliterGraphicsOutputSetMode,\r
121 ConSpliterGraphicsOutputBlt,\r
122 NULL\r
123};\r
124\r
125\r
126//\r
127// Text Out Splitter Private Data template\r
128//\r
129GLOBAL_REMOVE_IF_UNREFERENCED TEXT_OUT_SPLITTER_PRIVATE_DATA mConOut = {\r
130 TEXT_OUT_SPLITTER_PRIVATE_DATA_SIGNATURE,\r
131 (EFI_HANDLE) NULL,\r
132 {\r
133 ConSplitterTextOutReset,\r
134 ConSplitterTextOutOutputString,\r
135 ConSplitterTextOutTestString,\r
136 ConSplitterTextOutQueryMode,\r
137 ConSplitterTextOutSetMode,\r
138 ConSplitterTextOutSetAttribute,\r
139 ConSplitterTextOutClearScreen,\r
140 ConSplitterTextOutSetCursorPosition,\r
141 ConSplitterTextOutEnableCursor,\r
142 (EFI_SIMPLE_TEXT_OUTPUT_MODE *) NULL\r
143 },\r
144 {\r
145 1,\r
146 0,\r
147 0,\r
148 0,\r
149 0,\r
150 FALSE,\r
151 },\r
152\r
153 {\r
154 NULL,\r
155 NULL,\r
156 NULL\r
157 },\r
158 0,\r
159 0,\r
160 0,\r
161 0,\r
162\r
163 {\r
164 NULL,\r
165 NULL,\r
166 NULL,\r
167 NULL\r
168 },\r
169 (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *) NULL,\r
170 0,\r
171 0,\r
172 TRUE,\r
173\r
174 0,\r
175 (TEXT_OUT_AND_GOP_DATA *) NULL,\r
176 0,\r
177 (TEXT_OUT_SPLITTER_QUERY_DATA *) NULL,\r
178 0,\r
179 (INT32 *) NULL\r
180};\r
181\r
182//\r
183// Standard Error Text Out Splitter Data Template\r
184//\r
185GLOBAL_REMOVE_IF_UNREFERENCED TEXT_OUT_SPLITTER_PRIVATE_DATA mStdErr = {\r
186 TEXT_OUT_SPLITTER_PRIVATE_DATA_SIGNATURE,\r
187 (EFI_HANDLE) NULL,\r
188 {\r
189 ConSplitterTextOutReset,\r
190 ConSplitterTextOutOutputString,\r
191 ConSplitterTextOutTestString,\r
192 ConSplitterTextOutQueryMode,\r
193 ConSplitterTextOutSetMode,\r
194 ConSplitterTextOutSetAttribute,\r
195 ConSplitterTextOutClearScreen,\r
196 ConSplitterTextOutSetCursorPosition,\r
197 ConSplitterTextOutEnableCursor,\r
198 (EFI_SIMPLE_TEXT_OUTPUT_MODE *) NULL\r
199 },\r
200 {\r
201 1,\r
202 0,\r
203 0,\r
204 0,\r
205 0,\r
206 FALSE,\r
207 },\r
208\r
209 {\r
210 NULL,\r
211 NULL,\r
212 NULL\r
213 },\r
214 0,\r
215 0,\r
216 0,\r
217 0,\r
218\r
219 {\r
220 NULL,\r
221 NULL,\r
222 NULL,\r
223 NULL\r
224 },\r
225 (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *) NULL,\r
226 0,\r
227 0,\r
228 TRUE,\r
229\r
230 0,\r
231 (TEXT_OUT_AND_GOP_DATA *) NULL,\r
232 0,\r
233 (TEXT_OUT_SPLITTER_QUERY_DATA *) NULL,\r
234 0,\r
235 (INT32 *) NULL\r
236};\r
237\r
238//\r
239// Driver binding instance for Console Input Device\r
240//\r
241EFI_DRIVER_BINDING_PROTOCOL gConSplitterConInDriverBinding = {\r
242 ConSplitterConInDriverBindingSupported,\r
243 ConSplitterConInDriverBindingStart,\r
244 ConSplitterConInDriverBindingStop,\r
245 0xa,\r
246 NULL,\r
247 NULL\r
248};\r
249\r
250//\r
251// Driver binding instance for Console Out device\r
252//\r
253EFI_DRIVER_BINDING_PROTOCOL gConSplitterConOutDriverBinding = {\r
254 ConSplitterConOutDriverBindingSupported,\r
255 ConSplitterConOutDriverBindingStart,\r
256 ConSplitterConOutDriverBindingStop,\r
257 0xa,\r
258 NULL,\r
259 NULL\r
260};\r
261\r
262//\r
263// Driver binding instance for Standard Error device\r
264//\r
265EFI_DRIVER_BINDING_PROTOCOL gConSplitterStdErrDriverBinding = {\r
266 ConSplitterStdErrDriverBindingSupported,\r
267 ConSplitterStdErrDriverBindingStart,\r
268 ConSplitterStdErrDriverBindingStop,\r
269 0xa,\r
270 NULL,\r
271 NULL\r
272};\r
273\r
274//\r
275// Driver binding instance for Simple Pointer protocol\r
276//\r
277EFI_DRIVER_BINDING_PROTOCOL gConSplitterSimplePointerDriverBinding = {\r
278 ConSplitterSimplePointerDriverBindingSupported,\r
279 ConSplitterSimplePointerDriverBindingStart,\r
280 ConSplitterSimplePointerDriverBindingStop,\r
281 0xa,\r
282 NULL,\r
283 NULL\r
284};\r
285\r
286//\r
287// Driver binding instance for Absolute Pointer protocol\r
288//\r
289EFI_DRIVER_BINDING_PROTOCOL gConSplitterAbsolutePointerDriverBinding = {\r
290 ConSplitterAbsolutePointerDriverBindingSupported,\r
291 ConSplitterAbsolutePointerDriverBindingStart,\r
292 ConSplitterAbsolutePointerDriverBindingStop,\r
293 0xa,\r
294 NULL,\r
295 NULL\r
296};\r
297\r
298/**\r
299 The Entry Point for module ConSplitter. The user code starts with this function.\r
300\r
301 Installs driver module protocols and. Creates virtual device handles for ConIn,\r
302 ConOut, and StdErr. Installs Simple Text In protocol, Simple Text In Ex protocol,\r
303 Simple Pointer protocol, Absolute Pointer protocol on those virtual handlers.\r
304 Installs Graphics Output protocol and/or UGA Draw protocol if needed.\r
305\r
306 @param[in] ImageHandle The firmware allocated handle for the EFI image.\r
307 @param[in] SystemTable A pointer to the EFI System Table.\r
308\r
309 @retval EFI_SUCCESS The entry point is executed successfully.\r
310 @retval other Some error occurs when executing this entry point.\r
311\r
312**/\r
313EFI_STATUS\r
314EFIAPI\r
315ConSplitterDriverEntry(\r
316 IN EFI_HANDLE ImageHandle,\r
317 IN EFI_SYSTEM_TABLE *SystemTable\r
318 )\r
319{\r
320 EFI_STATUS Status;\r
321\r
322 //\r
323 // Install driver model protocol(s).\r
324 //\r
325 Status = EfiLibInstallDriverBindingComponentName2 (\r
326 ImageHandle,\r
327 SystemTable,\r
328 &gConSplitterConInDriverBinding,\r
329 ImageHandle,\r
330 &gConSplitterConInComponentName,\r
331 &gConSplitterConInComponentName2\r
332 );\r
333 ASSERT_EFI_ERROR (Status);\r
334\r
335 Status = EfiLibInstallDriverBindingComponentName2 (\r
336 ImageHandle,\r
337 SystemTable,\r
338 &gConSplitterSimplePointerDriverBinding,\r
339 NULL,\r
340 &gConSplitterSimplePointerComponentName,\r
341 &gConSplitterSimplePointerComponentName2\r
342 );\r
343 ASSERT_EFI_ERROR (Status);\r
344\r
345 Status = EfiLibInstallDriverBindingComponentName2 (\r
346 ImageHandle,\r
347 SystemTable,\r
348 &gConSplitterAbsolutePointerDriverBinding,\r
349 NULL,\r
350 &gConSplitterAbsolutePointerComponentName,\r
351 &gConSplitterAbsolutePointerComponentName2\r
352 );\r
353 ASSERT_EFI_ERROR (Status);\r
354\r
355 Status = EfiLibInstallDriverBindingComponentName2 (\r
356 ImageHandle,\r
357 SystemTable,\r
358 &gConSplitterConOutDriverBinding,\r
359 NULL,\r
360 &gConSplitterConOutComponentName,\r
361 &gConSplitterConOutComponentName2\r
362 );\r
363 ASSERT_EFI_ERROR (Status);\r
364\r
365 Status = EfiLibInstallDriverBindingComponentName2 (\r
366 ImageHandle,\r
367 SystemTable,\r
368 &gConSplitterStdErrDriverBinding,\r
369 NULL,\r
370 &gConSplitterStdErrComponentName,\r
371 &gConSplitterStdErrComponentName2\r
372 );\r
373 ASSERT_EFI_ERROR (Status);\r
374\r
375 //\r
376 // Either Graphics Output protocol or UGA Draw protocol must be supported.\r
377 //\r
378 ASSERT (FeaturePcdGet (PcdConOutGopSupport) ||\r
379 FeaturePcdGet (PcdConOutUgaSupport));\r
380\r
381 //\r
382 // The driver creates virtual handles for ConIn, ConOut, and StdErr.\r
383 // The virtual handles will always exist even if no console exist in the\r
384 // system. This is need to support hotplug devices like USB.\r
385 //\r
386 //\r
387 // Create virtual device handle for StdErr Splitter\r
388 //\r
389 Status = ConSplitterTextOutConstructor (&mStdErr);\r
390 if (!EFI_ERROR (Status)) {\r
391 Status = gBS->InstallMultipleProtocolInterfaces (\r
392 &mStdErr.VirtualHandle,\r
393 &gEfiSimpleTextOutProtocolGuid,\r
394 &mStdErr.TextOut,\r
395 NULL\r
396 );\r
397 }\r
398 //\r
399 // Create virtual device handle for ConIn Splitter\r
400 //\r
401 Status = ConSplitterTextInConstructor (&mConIn);\r
402 if (!EFI_ERROR (Status)) {\r
403 Status = gBS->InstallMultipleProtocolInterfaces (\r
404 &mConIn.VirtualHandle,\r
405 &gEfiSimpleTextInProtocolGuid,\r
406 &mConIn.TextIn,\r
407 &gEfiSimpleTextInputExProtocolGuid,\r
408 &mConIn.TextInEx,\r
409 &gEfiSimplePointerProtocolGuid,\r
410 &mConIn.SimplePointer,\r
411 &gEfiAbsolutePointerProtocolGuid,\r
412 &mConIn.AbsolutePointer,\r
413 NULL\r
414 );\r
415 if (!EFI_ERROR (Status)) {\r
416 //\r
417 // Update the EFI System Table with new virtual console\r
418 // and update the pointer to Simple Text Input protocol.\r
419 //\r
420 gST->ConsoleInHandle = mConIn.VirtualHandle;\r
421 gST->ConIn = &mConIn.TextIn;\r
422 }\r
423 }\r
424 //\r
425 // Create virtual device handle for ConOut Splitter\r
426 //\r
427 Status = ConSplitterTextOutConstructor (&mConOut);\r
428 if (!EFI_ERROR (Status)) {\r
429 if (!FeaturePcdGet (PcdConOutGopSupport)) {\r
430 //\r
431 // If Graphics Outpurt protocol not supported, UGA Draw protocol is installed\r
432 // on the virtual handle.\r
433 //\r
434 Status = gBS->InstallMultipleProtocolInterfaces (\r
435 &mConOut.VirtualHandle,\r
436 &gEfiSimpleTextOutProtocolGuid,\r
437 &mConOut.TextOut,\r
438 &gEfiUgaDrawProtocolGuid,\r
439 &mConOut.UgaDraw,\r
440 NULL\r
441 );\r
442 } else if (!FeaturePcdGet (PcdConOutUgaSupport)) {\r
443 //\r
444 // If UGA Draw protocol not supported, Graphics Output Protocol is installed\r
445 // on virtual handle.\r
446 //\r
447 Status = gBS->InstallMultipleProtocolInterfaces (\r
448 &mConOut.VirtualHandle,\r
449 &gEfiSimpleTextOutProtocolGuid,\r
450 &mConOut.TextOut,\r
451 &gEfiGraphicsOutputProtocolGuid,\r
452 &mConOut.GraphicsOutput,\r
453 NULL\r
454 );\r
455 } else {\r
456 //\r
457 // Boot Graphics Output protocol and UGA Draw protocol are supported,\r
458 // both they will be installed on virtual handle.\r
459 //\r
460 Status = gBS->InstallMultipleProtocolInterfaces (\r
461 &mConOut.VirtualHandle,\r
462 &gEfiSimpleTextOutProtocolGuid,\r
463 &mConOut.TextOut,\r
464 &gEfiGraphicsOutputProtocolGuid,\r
465 &mConOut.GraphicsOutput,\r
466 &gEfiUgaDrawProtocolGuid,\r
467 &mConOut.UgaDraw,\r
468 NULL\r
469 );\r
470 }\r
471\r
472 if (!EFI_ERROR (Status)) {\r
473 //\r
474 // Update the EFI System Table with new virtual console\r
475 // and Update the pointer to Text Output protocol.\r
476 //\r
477 gST->ConsoleOutHandle = mConOut.VirtualHandle;\r
478 gST->ConOut = &mConOut.TextOut;\r
479 }\r
480\r
481 }\r
482 //\r
483 // Update the CRC32 in the EFI System Table header\r
484 //\r
485 gST->Hdr.CRC32 = 0;\r
486 gBS->CalculateCrc32 (\r
487 (UINT8 *) &gST->Hdr,\r
488 gST->Hdr.HeaderSize,\r
489 &gST->Hdr.CRC32\r
490 );\r
491\r
492 return EFI_SUCCESS;\r
493\r
494}\r
495\r
496/**\r
497 Construct console input devices' private data.\r
498\r
499 @param ConInPrivate A pointer to the TEXT_IN_SPLITTER_PRIVATE_DATA\r
500 structure.\r
501\r
502 @retval EFI_OUT_OF_RESOURCES Out of resources.\r
503 @retval EFI_SUCCESS Text Input Devcie's private data has been constructed.\r
504 @retval other Failed to construct private data.\r
505\r
506**/\r
507EFI_STATUS\r
508ConSplitterTextInConstructor (\r
509 TEXT_IN_SPLITTER_PRIVATE_DATA *ConInPrivate\r
510 )\r
511{\r
512 EFI_STATUS Status;\r
513\r
514 //\r
515 // Allocate buffer for Simple Text Input device\r
516 //\r
517 Status = ConSplitterGrowBuffer (\r
518 sizeof (EFI_SIMPLE_TEXT_INPUT_PROTOCOL *),\r
519 &ConInPrivate->TextInListCount,\r
520 (VOID **) &ConInPrivate->TextInList\r
521 );\r
522 if (EFI_ERROR (Status)) {\r
523 return EFI_OUT_OF_RESOURCES;\r
524 }\r
525\r
526 //\r
527 // Create Event to wait for a key\r
528 //\r
529 Status = gBS->CreateEvent (\r
530 EVT_NOTIFY_WAIT,\r
531 TPL_NOTIFY,\r
532 ConSplitterTextInWaitForKey,\r
533 ConInPrivate,\r
534 &ConInPrivate->TextIn.WaitForKey\r
535 );\r
536 ASSERT_EFI_ERROR (Status);\r
537\r
538 //\r
539 // Allocate buffer for Simple Text Input Ex device\r
540 //\r
541 Status = ConSplitterGrowBuffer (\r
542 sizeof (EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *),\r
543 &ConInPrivate->TextInExListCount,\r
544 (VOID **) &ConInPrivate->TextInExList\r
545 );\r
546 if (EFI_ERROR (Status)) {\r
547 return EFI_OUT_OF_RESOURCES;\r
548 }\r
549 //\r
550 // Create Event to wait for a key Ex\r
551 //\r
552 Status = gBS->CreateEvent (\r
553 EVT_NOTIFY_WAIT,\r
554 TPL_NOTIFY,\r
555 ConSplitterTextInWaitForKey,\r
556 ConInPrivate,\r
557 &ConInPrivate->TextInEx.WaitForKeyEx\r
558 );\r
559 ASSERT_EFI_ERROR (Status);\r
560\r
561 InitializeListHead (&ConInPrivate->NotifyList);\r
562\r
563 ConInPrivate->AbsolutePointer.Mode = &ConInPrivate->AbsolutePointerMode;\r
564 //\r
565 // Allocate buffer for Absolute Pointer device\r
566 //\r
567 Status = ConSplitterGrowBuffer (\r
568 sizeof (EFI_ABSOLUTE_POINTER_PROTOCOL *),\r
569 &ConInPrivate->AbsolutePointerListCount,\r
570 (VOID **) &ConInPrivate->AbsolutePointerList\r
571 );\r
572 if (EFI_ERROR (Status)) {\r
573 return EFI_OUT_OF_RESOURCES;\r
574 }\r
575 //\r
576 // Create Event to wait for device input for Absolute pointer device\r
577 //\r
578 Status = gBS->CreateEvent (\r
579 EVT_NOTIFY_WAIT,\r
580 TPL_NOTIFY,\r
581 ConSplitterAbsolutePointerWaitForInput,\r
582 ConInPrivate,\r
583 &ConInPrivate->AbsolutePointer.WaitForInput\r
584 );\r
585 ASSERT_EFI_ERROR (Status);\r
586\r
587 ConInPrivate->SimplePointer.Mode = &ConInPrivate->SimplePointerMode;\r
588 //\r
589 // Allocate buffer for Simple Pointer device\r
590 //\r
591 Status = ConSplitterGrowBuffer (\r
592 sizeof (EFI_SIMPLE_POINTER_PROTOCOL *),\r
593 &ConInPrivate->PointerListCount,\r
594 (VOID **) &ConInPrivate->PointerList\r
595 );\r
596 if (EFI_ERROR (Status)) {\r
597 return EFI_OUT_OF_RESOURCES;\r
598 }\r
599 //\r
600 // Create Event to wait for device input for Simple pointer device\r
601 //\r
602 Status = gBS->CreateEvent (\r
603 EVT_NOTIFY_WAIT,\r
604 TPL_NOTIFY,\r
605 ConSplitterSimplePointerWaitForInput,\r
606 ConInPrivate,\r
607 &ConInPrivate->SimplePointer.WaitForInput\r
608 );\r
609\r
610 return Status;\r
611}\r
612\r
613/**\r
614 Construct console output devices' private data.\r
615\r
616 @param ConOutPrivate A pointer to the TEXT_OUT_SPLITTER_PRIVATE_DATA\r
617 structure.\r
618\r
619 @retval EFI_OUT_OF_RESOURCES Out of resources.\r
620 @retval EFI_SUCCESS Text Input Devcie's private data has been constructed.\r
621\r
622**/\r
623EFI_STATUS\r
624ConSplitterTextOutConstructor (\r
625 TEXT_OUT_SPLITTER_PRIVATE_DATA *ConOutPrivate\r
626 )\r
627{\r
628 EFI_STATUS Status;\r
629 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;\r
630\r
631 //\r
632 // Copy protocols template\r
633 //\r
634 if (FeaturePcdGet (PcdConOutUgaSupport)) {\r
635 CopyMem (&ConOutPrivate->UgaDraw, &mUgaDrawProtocolTemplate, sizeof (EFI_UGA_DRAW_PROTOCOL));\r
636 }\r
637 if (FeaturePcdGet (PcdConOutGopSupport)) {\r
638 CopyMem (&ConOutPrivate->GraphicsOutput, &mGraphicsOutputProtocolTemplate, sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL));\r
639 }\r
640\r
641 //\r
642 // Initilize console output splitter's private data.\r
643 //\r
644 ConOutPrivate->TextOut.Mode = &ConOutPrivate->TextOutMode;\r
645\r
646 //\r
647 // When new console device is added, the new mode will be set later,\r
648 // so put current mode back to init state.\r
649 //\r
650 ConOutPrivate->TextOutMode.Mode = 0xFF;\r
651 //\r
652 // Allocate buffer for Console Out device\r
653 //\r
654 Status = ConSplitterGrowBuffer (\r
655 sizeof (TEXT_OUT_AND_GOP_DATA),\r
656 &ConOutPrivate->TextOutListCount,\r
657 (VOID **) &ConOutPrivate->TextOutList\r
658 );\r
659 if (EFI_ERROR (Status)) {\r
660 return EFI_OUT_OF_RESOURCES;\r
661 }\r
662 //\r
663 // Allocate buffer for Text Out query data\r
664 //\r
665 Status = ConSplitterGrowBuffer (\r
666 sizeof (TEXT_OUT_SPLITTER_QUERY_DATA),\r
667 &ConOutPrivate->TextOutQueryDataCount,\r
668 (VOID **) &ConOutPrivate->TextOutQueryData\r
669 );\r
670 if (EFI_ERROR (Status)) {\r
671 return EFI_OUT_OF_RESOURCES;\r
672 }\r
673\r
674 //\r
675 // Setup the default console to 80 x 25 and mode to 0\r
676 //\r
677 ConOutPrivate->TextOutQueryData[0].Columns = 80;\r
678 ConOutPrivate->TextOutQueryData[0].Rows = 25;\r
679 TextOutSetMode (ConOutPrivate, 0);\r
680\r
681\r
682 if (FeaturePcdGet (PcdConOutUgaSupport)) {\r
683 //\r
684 // Setup the UgaDraw to 800 x 600 x 32 bits per pixel, 60Hz.\r
685 //\r
686 ConSpliterUgaDrawSetMode (&ConOutPrivate->UgaDraw, 800, 600, 32, 60);\r
687 }\r
688 if (FeaturePcdGet (PcdConOutGopSupport)) {\r
689 //\r
690 // Setup resource for mode information in Graphics Output Protocol interface\r
691 //\r
692 if ((ConOutPrivate->GraphicsOutput.Mode = AllocateZeroPool (sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE))) == NULL) {\r
693 return EFI_OUT_OF_RESOURCES;\r
694 }\r
695 if ((ConOutPrivate->GraphicsOutput.Mode->Info = AllocateZeroPool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION))) == NULL) {\r
696 return EFI_OUT_OF_RESOURCES;\r
697 }\r
698 //\r
699 // Setup the DevNullGraphicsOutput to 800 x 600 x 32 bits per pixel\r
700 // DevNull will be updated to user-defined mode after driver has started.\r
701 //\r
702 if ((ConOutPrivate->GraphicsOutputModeBuffer = AllocateZeroPool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION))) == NULL) {\r
703 return EFI_OUT_OF_RESOURCES;\r
704 }\r
705 Info = &ConOutPrivate->GraphicsOutputModeBuffer[0];\r
706 Info->Version = 0;\r
707 Info->HorizontalResolution = 800;\r
708 Info->VerticalResolution = 600;\r
709 Info->PixelFormat = PixelBltOnly;\r
710 Info->PixelsPerScanLine = 800;\r
711 CopyMem (ConOutPrivate->GraphicsOutput.Mode->Info, Info, sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));\r
712 ConOutPrivate->GraphicsOutput.Mode->SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);\r
713\r
714 //\r
715 // Initialize the following items, theset items remain unchanged in GraphicsOutput->SetMode()\r
716 // GraphicsOutputMode->FrameBufferBase, GraphicsOutputMode->FrameBufferSize\r
717 //\r
718 ConOutPrivate->GraphicsOutput.Mode->FrameBufferBase = (EFI_PHYSICAL_ADDRESS) (UINTN) NULL;\r
719 ConOutPrivate->GraphicsOutput.Mode->FrameBufferSize = 0;\r
720\r
721 ConOutPrivate->GraphicsOutput.Mode->MaxMode = 1;\r
722 //\r
723 // Initial current mode to unknown state, and then set to mode 0\r
724 //\r
725 ConOutPrivate->GraphicsOutput.Mode->Mode = 0xffff;\r
726 ConOutPrivate->GraphicsOutput.SetMode (&ConOutPrivate->GraphicsOutput, 0);\r
727 }\r
728\r
729 return EFI_SUCCESS;\r
730}\r
731\r
732\r
733/**\r
734 Test to see if the specified protocol could be supported on the specified device.\r
735\r
736 @param This Driver Binding protocol pointer.\r
737 @param ControllerHandle Handle of device to test.\r
738 @param Guid The specified protocol.\r
739\r
740 @retval EFI_SUCCESS The specified protocol is supported on this device.\r
741 @retval EFI_UNSUPPORTED The specified protocol attempts to be installed on virtul handle.\r
742 @retval other Failed to open specified protocol on this device.\r
743\r
744**/\r
745EFI_STATUS\r
746ConSplitterSupported (\r
747 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
748 IN EFI_HANDLE ControllerHandle,\r
749 IN EFI_GUID *Guid\r
750 )\r
751{\r
752 EFI_STATUS Status;\r
753 VOID *Instance;\r
754\r
755 //\r
756 // Make sure the Console Splitter does not attempt to attach to itself\r
757 //\r
758 if (ControllerHandle == mConIn.VirtualHandle ||\r
759 ControllerHandle == mConOut.VirtualHandle ||\r
760 ControllerHandle == mStdErr.VirtualHandle\r
761 ) {\r
762 return EFI_UNSUPPORTED;\r
763 }\r
764\r
765 //\r
766 // Check to see whether the specific protocol could be opened BY_DRIVER\r
767 //\r
768 Status = gBS->OpenProtocol (\r
769 ControllerHandle,\r
770 Guid,\r
771 &Instance,\r
772 This->DriverBindingHandle,\r
773 ControllerHandle,\r
774 EFI_OPEN_PROTOCOL_BY_DRIVER\r
775 );\r
776\r
777 if (EFI_ERROR (Status)) {\r
778 return Status;\r
779 }\r
780\r
781 gBS->CloseProtocol (\r
782 ControllerHandle,\r
783 Guid,\r
784 This->DriverBindingHandle,\r
785 ControllerHandle\r
786 );\r
787\r
788 return EFI_SUCCESS;\r
789}\r
790\r
791/**\r
792 Test to see if Console In Device could be supported on the Controller.\r
793\r
794 @param This Driver Binding protocol instance pointer.\r
795 @param ControllerHandle Handle of device to test.\r
796 @param RemainingDevicePath Optional parameter use to pick a specific child\r
797 device to start.\r
798\r
799 @retval EFI_SUCCESS This driver supports this device.\r
800 @retval other This driver does not support this device.\r
801\r
802**/\r
803EFI_STATUS\r
804EFIAPI\r
805ConSplitterConInDriverBindingSupported (\r
806 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
807 IN EFI_HANDLE ControllerHandle,\r
808 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
809 )\r
810{\r
811 return ConSplitterSupported (\r
812 This,\r
813 ControllerHandle,\r
814 &gEfiConsoleInDeviceGuid\r
815 );\r
816}\r
817\r
818/**\r
819 Test to see if Simple Pointer protocol could be supported on the Controller.\r
820\r
821 @param This Driver Binding protocol instance pointer.\r
822 @param ControllerHandle Handle of device to test.\r
823 @param RemainingDevicePath Optional parameter use to pick a specific child\r
824 device to start.\r
825\r
826 @retval EFI_SUCCESS This driver supports this device.\r
827 @retval other This driver does not support this device.\r
828\r
829**/\r
830EFI_STATUS\r
831EFIAPI\r
832ConSplitterSimplePointerDriverBindingSupported (\r
833 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
834 IN EFI_HANDLE ControllerHandle,\r
835 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
836 )\r
837{\r
838 return ConSplitterSupported (\r
839 This,\r
840 ControllerHandle,\r
841 &gEfiSimplePointerProtocolGuid\r
842 );\r
843}\r
844\r
845/**\r
846 Test to see if Absolute Pointer protocol could be supported on the Controller.\r
847\r
848 @param This Driver Binding protocol instance pointer.\r
849 @param ControllerHandle Handle of device to test.\r
850 @param RemainingDevicePath Optional parameter use to pick a specific child\r
851 device to start.\r
852\r
853 @retval EFI_SUCCESS This driver supports this device.\r
854 @retval other This driver does not support this device.\r
855\r
856**/\r
857EFI_STATUS\r
858EFIAPI\r
859ConSplitterAbsolutePointerDriverBindingSupported (\r
860 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
861 IN EFI_HANDLE ControllerHandle,\r
862 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
863 )\r
864{\r
865 return ConSplitterSupported (\r
866 This,\r
867 ControllerHandle,\r
868 &gEfiAbsolutePointerProtocolGuid\r
869 );\r
870}\r
871\r
872\r
873/**\r
874 Test to see if Console Out Device could be supported on the Controller.\r
875\r
876 @param This Driver Binding protocol instance pointer.\r
877 @param ControllerHandle Handle of device to test.\r
878 @param RemainingDevicePath Optional parameter use to pick a specific child\r
879 device to start.\r
880\r
881 @retval EFI_SUCCESS This driver supports this device.\r
882 @retval other This driver does not support this device.\r
883\r
884**/\r
885EFI_STATUS\r
886EFIAPI\r
887ConSplitterConOutDriverBindingSupported (\r
888 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
889 IN EFI_HANDLE ControllerHandle,\r
890 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
891 )\r
892{\r
893 return ConSplitterSupported (\r
894 This,\r
895 ControllerHandle,\r
896 &gEfiConsoleOutDeviceGuid\r
897 );\r
898}\r
899\r
900/**\r
901 Test to see if Standard Error Device could be supported on the Controller.\r
902\r
903 @param This Driver Binding protocol instance pointer.\r
904 @param ControllerHandle Handle of device to test.\r
905 @param RemainingDevicePath Optional parameter use to pick a specific child\r
906 device to start.\r
907\r
908 @retval EFI_SUCCESS This driver supports this device.\r
909 @retval other This driver does not support this device.\r
910\r
911**/\r
912EFI_STATUS\r
913EFIAPI\r
914ConSplitterStdErrDriverBindingSupported (\r
915 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
916 IN EFI_HANDLE ControllerHandle,\r
917 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
918 )\r
919{\r
920 return ConSplitterSupported (\r
921 This,\r
922 ControllerHandle,\r
923 &gEfiStandardErrorDeviceGuid\r
924 );\r
925}\r
926\r
927\r
928/**\r
929 Start ConSplitter on devcie handle by opening Console Device Guid on device handle\r
930 and the console virtual handle. And Get the console interface on controller handle.\r
931\r
932 @param This Driver Binding protocol instance pointer.\r
933 @param ControllerHandle Handle of device.\r
934 @param ConSplitterVirtualHandle Console virtual Handle.\r
935 @param DeviceGuid The specified Console Device, such as ConInDev,\r
936 ConOutDev.\r
937 @param InterfaceGuid The specified protocol to be opened.\r
938 @param Interface Protocol interface returned.\r
939\r
940 @retval EFI_SUCCESS This driver supports this device.\r
941 @retval other Failed to open the specified Console Device Guid\r
942 or specified protocol.\r
943\r
944**/\r
945EFI_STATUS\r
946ConSplitterStart (\r
947 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
948 IN EFI_HANDLE ControllerHandle,\r
949 IN EFI_HANDLE ConSplitterVirtualHandle,\r
950 IN EFI_GUID *DeviceGuid,\r
951 IN EFI_GUID *InterfaceGuid,\r
952 OUT VOID **Interface\r
953 )\r
954{\r
955 EFI_STATUS Status;\r
956 VOID *Instance;\r
957\r
958 //\r
959 // Check to see whether the ControllerHandle has the DeviceGuid on it.\r
960 //\r
961 Status = gBS->OpenProtocol (\r
962 ControllerHandle,\r
963 DeviceGuid,\r
964 &Instance,\r
965 This->DriverBindingHandle,\r
966 ControllerHandle,\r
967 EFI_OPEN_PROTOCOL_BY_DRIVER\r
968 );\r
969 if (EFI_ERROR (Status)) {\r
970 return Status;\r
971 }\r
972\r
973 //\r
974 // Create virtual handle and open DeviceGuid on the virtul handle.\r
975 //\r
976 Status = gBS->OpenProtocol (\r
977 ControllerHandle,\r
978 DeviceGuid,\r
979 &Instance,\r
980 This->DriverBindingHandle,\r
981 ConSplitterVirtualHandle,\r
982 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER\r
983 );\r
984 if (EFI_ERROR (Status)) {\r
985 goto Err;\r
986 }\r
987\r
988 //\r
989 // Open InterfaceGuid on the virtul handle.\r
990 //\r
991 Status = gBS->OpenProtocol (\r
992 ControllerHandle,\r
993 InterfaceGuid,\r
994 Interface,\r
995 This->DriverBindingHandle,\r
996 ConSplitterVirtualHandle,\r
997 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
998 );\r
999\r
1000 if (!EFI_ERROR (Status)) {\r
1001 return EFI_SUCCESS;\r
1002 }\r
1003\r
1004 //\r
1005 // close the DeviceGuid on ConSplitter VirtualHandle.\r
1006 //\r
1007 gBS->CloseProtocol (\r
1008 ControllerHandle,\r
1009 DeviceGuid,\r
1010 This->DriverBindingHandle,\r
1011 ConSplitterVirtualHandle\r
1012 );\r
1013\r
1014Err:\r
1015 //\r
1016 // close the DeviceGuid on ControllerHandle.\r
1017 //\r
1018 gBS->CloseProtocol (\r
1019 ControllerHandle,\r
1020 DeviceGuid,\r
1021 This->DriverBindingHandle,\r
1022 ControllerHandle\r
1023 );\r
1024\r
1025 return Status;\r
1026}\r
1027\r
1028\r
1029/**\r
1030 Start Console In Consplitter on device handle.\r
1031\r
1032 @param This Driver Binding protocol instance pointer.\r
1033 @param ControllerHandle Handle of device to bind driver to.\r
1034 @param RemainingDevicePath Optional parameter use to pick a specific child\r
1035 device to start.\r
1036\r
1037 @retval EFI_SUCCESS Console In Consplitter is added to ControllerHandle.\r
1038 @retval other Console In Consplitter does not support this device.\r
1039\r
1040**/\r
1041EFI_STATUS\r
1042EFIAPI\r
1043ConSplitterConInDriverBindingStart (\r
1044 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
1045 IN EFI_HANDLE ControllerHandle,\r
1046 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
1047 )\r
1048{\r
1049 EFI_STATUS Status;\r
1050 EFI_SIMPLE_TEXT_INPUT_PROTOCOL *TextIn;\r
1051 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TextInEx;\r
1052\r
1053 //\r
1054 // Start ConSplitter on ControllerHandle, and create the virtual\r
1055 // agrogated console device on first call Start for a SimpleTextIn handle.\r
1056 //\r
1057 Status = ConSplitterStart (\r
1058 This,\r
1059 ControllerHandle,\r
1060 mConIn.VirtualHandle,\r
1061 &gEfiConsoleInDeviceGuid,\r
1062 &gEfiSimpleTextInProtocolGuid,\r
1063 (VOID **) &TextIn\r
1064 );\r
1065 if (EFI_ERROR (Status)) {\r
1066 return Status;\r
1067 }\r
1068\r
1069 //\r
1070 // Add this device into Text In devices list.\r
1071 //\r
1072 Status = ConSplitterTextInAddDevice (&mConIn, TextIn);\r
1073 if (EFI_ERROR (Status)) {\r
1074 return Status;\r
1075 }\r
1076\r
1077 Status = gBS->OpenProtocol (\r
1078 ControllerHandle,\r
1079 &gEfiSimpleTextInputExProtocolGuid,\r
1080 (VOID **) &TextInEx,\r
1081 This->DriverBindingHandle,\r
1082 mConIn.VirtualHandle,\r
1083 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
1084 );\r
1085 if (!EFI_ERROR (Status)) {\r
1086 //\r
1087 // If Simple Text Input Ex protocol exists,\r
1088 // add this device into Text In Ex devices list.\r
1089 //\r
1090 Status = ConSplitterTextInExAddDevice (&mConIn, TextInEx);\r
1091 }\r
1092\r
1093 return Status;\r
1094}\r
1095\r
1096\r
1097/**\r
1098 Start Simple Pointer Consplitter on device handle.\r
1099\r
1100 @param This Driver Binding protocol instance pointer.\r
1101 @param ControllerHandle Handle of device to bind driver to.\r
1102 @param RemainingDevicePath Optional parameter use to pick a specific child\r
1103 device to start.\r
1104\r
1105 @retval EFI_SUCCESS Simple Pointer Consplitter is added to ControllerHandle.\r
1106 @retval other Simple Pointer Consplitter does not support this device.\r
1107\r
1108**/\r
1109EFI_STATUS\r
1110EFIAPI\r
1111ConSplitterSimplePointerDriverBindingStart (\r
1112 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
1113 IN EFI_HANDLE ControllerHandle,\r
1114 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
1115 )\r
1116{\r
1117 EFI_STATUS Status;\r
1118 EFI_SIMPLE_POINTER_PROTOCOL *SimplePointer;\r
1119\r
1120 //\r
1121 // Start ConSplitter on ControllerHandle, and create the virtual\r
1122 // agrogated console device on first call Start for a SimplePointer handle.\r
1123 //\r
1124 Status = ConSplitterStart (\r
1125 This,\r
1126 ControllerHandle,\r
1127 mConIn.VirtualHandle,\r
1128 &gEfiSimplePointerProtocolGuid,\r
1129 &gEfiSimplePointerProtocolGuid,\r
1130 (VOID **) &SimplePointer\r
1131 );\r
1132 if (EFI_ERROR (Status)) {\r
1133 return Status;\r
1134 }\r
1135\r
1136 //\r
1137 // Add this devcie into Simple Pointer devices list.\r
1138 //\r
1139 return ConSplitterSimplePointerAddDevice (&mConIn, SimplePointer);\r
1140}\r
1141\r
1142\r
1143/**\r
1144 Start Absolute Pointer Consplitter on device handle.\r
1145\r
1146 @param This Driver Binding protocol instance pointer.\r
1147 @param ControllerHandle Handle of device to bind driver to.\r
1148 @param RemainingDevicePath Optional parameter use to pick a specific child\r
1149 device to start.\r
1150\r
1151 @retval EFI_SUCCESS Absolute Pointer Consplitter is added to ControllerHandle.\r
1152 @retval other Absolute Pointer Consplitter does not support this device.\r
1153\r
1154**/\r
1155EFI_STATUS\r
1156EFIAPI\r
1157ConSplitterAbsolutePointerDriverBindingStart (\r
1158 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
1159 IN EFI_HANDLE ControllerHandle,\r
1160 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
1161 )\r
1162{\r
1163 EFI_STATUS Status;\r
1164 EFI_ABSOLUTE_POINTER_PROTOCOL *AbsolutePointer;\r
1165\r
1166 //\r
1167 // Start ConSplitter on ControllerHandle, and create the virtual\r
1168 // agrogated console device on first call Start for a AbsolutePointer handle.\r
1169 //\r
1170 Status = ConSplitterStart (\r
1171 This,\r
1172 ControllerHandle,\r
1173 mConIn.VirtualHandle,\r
1174 &gEfiAbsolutePointerProtocolGuid,\r
1175 &gEfiAbsolutePointerProtocolGuid,\r
1176 (VOID **) &AbsolutePointer\r
1177 );\r
1178\r
1179 if (EFI_ERROR (Status)) {\r
1180 return Status;\r
1181 }\r
1182\r
1183 //\r
1184 // Add this devcie into Absolute Pointer devices list.\r
1185 //\r
1186 return ConSplitterAbsolutePointerAddDevice (&mConIn, AbsolutePointer);\r
1187}\r
1188\r
1189\r
1190/**\r
1191 Start Console Out Consplitter on device handle.\r
1192\r
1193 @param This Driver Binding protocol instance pointer.\r
1194 @param ControllerHandle Handle of device to bind driver to.\r
1195 @param RemainingDevicePath Optional parameter use to pick a specific child\r
1196 device to start.\r
1197\r
1198 @retval EFI_SUCCESS Console Out Consplitter is added to ControllerHandle.\r
1199 @retval other Console Out Consplitter does not support this device.\r
1200\r
1201**/\r
1202EFI_STATUS\r
1203EFIAPI\r
1204ConSplitterConOutDriverBindingStart (\r
1205 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
1206 IN EFI_HANDLE ControllerHandle,\r
1207 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
1208 )\r
1209{\r
1210 EFI_STATUS Status;\r
1211 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut;\r
1212 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;\r
1213 EFI_UGA_DRAW_PROTOCOL *UgaDraw;\r
1214 UINTN SizeOfInfo;\r
1215 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;\r
1216\r
1217 //\r
1218 // Start ConSplitter on ControllerHandle, and create the virtual\r
1219 // agrogated console device on first call Start for a ConsoleOut handle.\r
1220 //\r
1221 Status = ConSplitterStart (\r
1222 This,\r
1223 ControllerHandle,\r
1224 mConOut.VirtualHandle,\r
1225 &gEfiConsoleOutDeviceGuid,\r
1226 &gEfiSimpleTextOutProtocolGuid,\r
1227 (VOID **) &TextOut\r
1228 );\r
1229 if (EFI_ERROR (Status)) {\r
1230 return Status;\r
1231 }\r
1232\r
1233 GraphicsOutput = NULL;\r
1234 UgaDraw = NULL;\r
1235 //\r
1236 // Try to Open Graphics Output protocol\r
1237 //\r
1238 Status = gBS->OpenProtocol (\r
1239 ControllerHandle,\r
1240 &gEfiGraphicsOutputProtocolGuid,\r
1241 (VOID **) &GraphicsOutput,\r
1242 This->DriverBindingHandle,\r
1243 mConOut.VirtualHandle,\r
1244 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
1245 );\r
1246\r
1247 if (EFI_ERROR (Status) && FeaturePcdGet (PcdUgaConsumeSupport)) {\r
1248 //\r
1249 // Open UGA DRAW protocol\r
1250 //\r
1251 gBS->OpenProtocol (\r
1252 ControllerHandle,\r
1253 &gEfiUgaDrawProtocolGuid,\r
1254 (VOID **) &UgaDraw,\r
1255 This->DriverBindingHandle,\r
1256 mConOut.VirtualHandle,\r
1257 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
1258 );\r
1259 }\r
1260\r
1261 //\r
1262 // When new console device is added, the new mode will be set later,\r
1263 // so put current mode back to init state.\r
1264 //\r
1265 mConOut.TextOutMode.Mode = 0xFF;\r
1266\r
1267 //\r
1268 // If both ConOut and StdErr incorporate the same Text Out device,\r
1269 // their MaxMode and QueryData should be the intersection of both.\r
1270 //\r
1271 Status = ConSplitterTextOutAddDevice (&mConOut, TextOut, GraphicsOutput, UgaDraw);\r
1272 ConSplitterTextOutSetAttribute (&mConOut.TextOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));\r
1273\r
1274 if (FeaturePcdGet (PcdConOutUgaSupport)) {\r
1275 //\r
1276 // Get the UGA mode data of ConOut from the current mode\r
1277 //\r
1278 if (GraphicsOutput != NULL) {\r
1279 Status = GraphicsOutput->QueryMode (GraphicsOutput, GraphicsOutput->Mode->Mode, &SizeOfInfo, &Info);\r
1280 if (EFI_ERROR (Status)) {\r
1281 return Status;\r
1282 }\r
1283 ASSERT ( SizeOfInfo <= sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));\r
1284\r
1285 mConOut.UgaHorizontalResolution = Info->HorizontalResolution;\r
1286 mConOut.UgaVerticalResolution = Info->VerticalResolution;\r
1287 mConOut.UgaColorDepth = 32;\r
1288 mConOut.UgaRefreshRate = 60;\r
1289\r
1290 FreePool (Info);\r
1291\r
1292 } else if (UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {\r
1293 Status = UgaDraw->GetMode (\r
1294 UgaDraw,\r
1295 &mConOut.UgaHorizontalResolution,\r
1296 &mConOut.UgaVerticalResolution,\r
1297 &mConOut.UgaColorDepth,\r
1298 &mConOut.UgaRefreshRate\r
1299 );\r
1300 }\r
1301 }\r
1302\r
1303 return Status;\r
1304}\r
1305\r
1306\r
1307/**\r
1308 Start Standard Error Consplitter on device handle.\r
1309\r
1310 @param This Driver Binding protocol instance pointer.\r
1311 @param ControllerHandle Handle of device to bind driver to.\r
1312 @param RemainingDevicePath Optional parameter use to pick a specific child\r
1313 device to start.\r
1314\r
1315 @retval EFI_SUCCESS Standard Error Consplitter is added to ControllerHandle.\r
1316 @retval other Standard Error Consplitter does not support this device.\r
1317\r
1318**/\r
1319EFI_STATUS\r
1320EFIAPI\r
1321ConSplitterStdErrDriverBindingStart (\r
1322 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
1323 IN EFI_HANDLE ControllerHandle,\r
1324 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
1325 )\r
1326{\r
1327 EFI_STATUS Status;\r
1328 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut;\r
1329\r
1330 //\r
1331 // Start ConSplitter on ControllerHandle, and create the virtual\r
1332 // agrogated console device on first call Start for a StandardError handle.\r
1333 //\r
1334 Status = ConSplitterStart (\r
1335 This,\r
1336 ControllerHandle,\r
1337 mStdErr.VirtualHandle,\r
1338 &gEfiStandardErrorDeviceGuid,\r
1339 &gEfiSimpleTextOutProtocolGuid,\r
1340 (VOID **) &TextOut\r
1341 );\r
1342 if (EFI_ERROR (Status)) {\r
1343 return Status;\r
1344 }\r
1345\r
1346 //\r
1347 // When new console device is added, the new mode will be set later,\r
1348 // so put current mode back to init state.\r
1349 //\r
1350 mStdErr.TextOutMode.Mode = 0xFF;\r
1351\r
1352 //\r
1353 // If both ConOut and StdErr incorporate the same Text Out device,\r
1354 // their MaxMode and QueryData should be the intersection of both.\r
1355 //\r
1356 Status = ConSplitterTextOutAddDevice (&mStdErr, TextOut, NULL, NULL);\r
1357 ConSplitterTextOutSetAttribute (&mStdErr.TextOut, EFI_TEXT_ATTR (EFI_MAGENTA, EFI_BLACK));\r
1358 if (EFI_ERROR (Status)) {\r
1359 return Status;\r
1360 }\r
1361\r
1362 if (mStdErr.CurrentNumberOfConsoles == 1) {\r
1363 gST->StandardErrorHandle = mStdErr.VirtualHandle;\r
1364 gST->StdErr = &mStdErr.TextOut;\r
1365 //\r
1366 // Update the CRC32 in the EFI System Table header\r
1367 //\r
1368 gST->Hdr.CRC32 = 0;\r
1369 gBS->CalculateCrc32 (\r
1370 (UINT8 *) &gST->Hdr,\r
1371 gST->Hdr.HeaderSize,\r
1372 &gST->Hdr.CRC32\r
1373 );\r
1374 }\r
1375\r
1376 return Status;\r
1377}\r
1378\r
1379\r
1380/**\r
1381 Stop ConSplitter on device handle by closing Console Device Guid on device handle\r
1382 and the console virtual handle.\r
1383\r
1384 @param This Protocol instance pointer.\r
1385 @param ControllerHandle Handle of device.\r
1386 @param ConSplitterVirtualHandle Console virtual Handle.\r
1387 @param DeviceGuid The specified Console Device, such as ConInDev,\r
1388 ConOutDev.\r
1389 @param InterfaceGuid The specified protocol to be opened.\r
1390 @param Interface Protocol interface returned.\r
1391\r
1392 @retval EFI_SUCCESS Stop ConSplitter on ControllerHandle successfully.\r
1393 @retval other Failed to Stop ConSplitter on ControllerHandle.\r
1394\r
1395**/\r
1396EFI_STATUS\r
1397ConSplitterStop (\r
1398 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
1399 IN EFI_HANDLE ControllerHandle,\r
1400 IN EFI_HANDLE ConSplitterVirtualHandle,\r
1401 IN EFI_GUID *DeviceGuid,\r
1402 IN EFI_GUID *InterfaceGuid,\r
1403 IN VOID **Interface\r
1404 )\r
1405{\r
1406 EFI_STATUS Status;\r
1407\r
1408 Status = gBS->OpenProtocol (\r
1409 ControllerHandle,\r
1410 InterfaceGuid,\r
1411 Interface,\r
1412 This->DriverBindingHandle,\r
1413 ControllerHandle,\r
1414 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
1415 );\r
1416 if (EFI_ERROR (Status)) {\r
1417 return Status;\r
1418 }\r
1419 //\r
1420 // close the protocol refered.\r
1421 //\r
1422 gBS->CloseProtocol (\r
1423 ControllerHandle,\r
1424 DeviceGuid,\r
1425 This->DriverBindingHandle,\r
1426 ConSplitterVirtualHandle\r
1427 );\r
1428\r
1429 gBS->CloseProtocol (\r
1430 ControllerHandle,\r
1431 DeviceGuid,\r
1432 This->DriverBindingHandle,\r
1433 ControllerHandle\r
1434 );\r
1435\r
1436 return EFI_SUCCESS;\r
1437}\r
1438\r
1439\r
1440/**\r
1441 Stop Console In ConSplitter on ControllerHandle by closing Console In Devcice GUID.\r
1442\r
1443 @param This Driver Binding protocol instance pointer.\r
1444 @param ControllerHandle Handle of device to stop driver on\r
1445 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of\r
1446 children is zero stop the entire bus driver.\r
1447 @param ChildHandleBuffer List of Child Handles to Stop.\r
1448\r
1449 @retval EFI_SUCCESS This driver is removed ControllerHandle\r
1450 @retval other This driver was not removed from this device\r
1451\r
1452**/\r
1453EFI_STATUS\r
1454EFIAPI\r
1455ConSplitterConInDriverBindingStop (\r
1456 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
1457 IN EFI_HANDLE ControllerHandle,\r
1458 IN UINTN NumberOfChildren,\r
1459 IN EFI_HANDLE *ChildHandleBuffer\r
1460 )\r
1461{\r
1462 EFI_STATUS Status;\r
1463 EFI_SIMPLE_TEXT_INPUT_PROTOCOL *TextIn;\r
1464 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TextInEx;\r
1465\r
1466 if (NumberOfChildren == 0) {\r
1467 return EFI_SUCCESS;\r
1468 }\r
1469\r
1470 Status = gBS->OpenProtocol (\r
1471 ControllerHandle,\r
1472 &gEfiSimpleTextInputExProtocolGuid,\r
1473 (VOID **) &TextInEx,\r
1474 This->DriverBindingHandle,\r
1475 ControllerHandle,\r
1476 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
1477 );\r
1478 if (!EFI_ERROR (Status)) {\r
1479 //\r
1480 // If Simple Text Input Ex protocol exists,\r
1481 // remove device from Text Input Ex devices list.\r
1482 //\r
1483 Status = ConSplitterTextInExDeleteDevice (&mConIn, TextInEx);\r
1484 if (EFI_ERROR (Status)) {\r
1485 return Status;\r
1486 }\r
1487 }\r
1488\r
1489 //\r
1490 // Close Simple Text In protocol on controller handle and virtual handle.\r
1491 //\r
1492 Status = ConSplitterStop (\r
1493 This,\r
1494 ControllerHandle,\r
1495 mConIn.VirtualHandle,\r
1496 &gEfiConsoleInDeviceGuid,\r
1497 &gEfiSimpleTextInProtocolGuid,\r
1498 (VOID **) &TextIn\r
1499 );\r
1500 if (EFI_ERROR (Status)) {\r
1501 return Status;\r
1502 }\r
1503\r
1504 //\r
1505 // Remove device from Text Input devices list.\r
1506 //\r
1507 return ConSplitterTextInDeleteDevice (&mConIn, TextIn);\r
1508}\r
1509\r
1510\r
1511/**\r
1512 Stop Simple Pointer protocol ConSplitter on ControllerHandle by closing\r
1513 Simple Pointer protocol.\r
1514\r
1515 @param This Driver Binding protocol instance pointer.\r
1516 @param ControllerHandle Handle of device to stop driver on\r
1517 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of\r
1518 children is zero stop the entire bus driver.\r
1519 @param ChildHandleBuffer List of Child Handles to Stop.\r
1520\r
1521 @retval EFI_SUCCESS This driver is removed ControllerHandle\r
1522 @retval other This driver was not removed from this device\r
1523\r
1524**/\r
1525EFI_STATUS\r
1526EFIAPI\r
1527ConSplitterSimplePointerDriverBindingStop (\r
1528 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
1529 IN EFI_HANDLE ControllerHandle,\r
1530 IN UINTN NumberOfChildren,\r
1531 IN EFI_HANDLE *ChildHandleBuffer\r
1532 )\r
1533{\r
1534 EFI_STATUS Status;\r
1535 EFI_SIMPLE_POINTER_PROTOCOL *SimplePointer;\r
1536\r
1537 if (NumberOfChildren == 0) {\r
1538 return EFI_SUCCESS;\r
1539 }\r
1540\r
1541 //\r
1542 // Close Simple Pointer protocol on controller handle and virtual handle.\r
1543 //\r
1544 Status = ConSplitterStop (\r
1545 This,\r
1546 ControllerHandle,\r
1547 mConIn.VirtualHandle,\r
1548 &gEfiSimplePointerProtocolGuid,\r
1549 &gEfiSimplePointerProtocolGuid,\r
1550 (VOID **) &SimplePointer\r
1551 );\r
1552 if (EFI_ERROR (Status)) {\r
1553 return Status;\r
1554 }\r
1555\r
1556 //\r
1557 // Remove this device from Simple Pointer device list.\r
1558 //\r
1559 return ConSplitterSimplePointerDeleteDevice (&mConIn, SimplePointer);\r
1560}\r
1561\r
1562\r
1563/**\r
1564 Stop Absolute Pointer protocol ConSplitter on ControllerHandle by closing\r
1565 Absolute Pointer protocol.\r
1566\r
1567 @param This Driver Binding protocol instance pointer.\r
1568 @param ControllerHandle Handle of device to stop driver on\r
1569 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of\r
1570 children is zero stop the entire bus driver.\r
1571 @param ChildHandleBuffer List of Child Handles to Stop.\r
1572\r
1573 @retval EFI_SUCCESS This driver is removed ControllerHandle\r
1574 @retval other This driver was not removed from this device\r
1575\r
1576**/\r
1577EFI_STATUS\r
1578EFIAPI\r
1579ConSplitterAbsolutePointerDriverBindingStop (\r
1580 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
1581 IN EFI_HANDLE ControllerHandle,\r
1582 IN UINTN NumberOfChildren,\r
1583 IN EFI_HANDLE *ChildHandleBuffer\r
1584 )\r
1585{\r
1586 EFI_STATUS Status;\r
1587 EFI_ABSOLUTE_POINTER_PROTOCOL *AbsolutePointer;\r
1588\r
1589 if (NumberOfChildren == 0) {\r
1590 return EFI_SUCCESS;\r
1591 }\r
1592\r
1593 //\r
1594 // Close Absolute Pointer protocol on controller handle and virtual handle.\r
1595 //\r
1596 Status = ConSplitterStop (\r
1597 This,\r
1598 ControllerHandle,\r
1599 mConIn.VirtualHandle,\r
1600 &gEfiAbsolutePointerProtocolGuid,\r
1601 &gEfiAbsolutePointerProtocolGuid,\r
1602 (VOID **) &AbsolutePointer\r
1603 );\r
1604 if (EFI_ERROR (Status)) {\r
1605 return Status;\r
1606 }\r
1607\r
1608 //\r
1609 // Remove this device from Absolute Pointer device list.\r
1610 //\r
1611 return ConSplitterAbsolutePointerDeleteDevice (&mConIn, AbsolutePointer);\r
1612}\r
1613\r
1614\r
1615/**\r
1616 Stop Console Out ConSplitter on device handle by closing Console Out Devcice GUID.\r
1617\r
1618 @param This Driver Binding protocol instance pointer.\r
1619 @param ControllerHandle Handle of device to stop driver on\r
1620 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of\r
1621 children is zero stop the entire bus driver.\r
1622 @param ChildHandleBuffer List of Child Handles to Stop.\r
1623\r
1624 @retval EFI_SUCCESS This driver is removed ControllerHandle\r
1625 @retval other This driver was not removed from this device\r
1626\r
1627**/\r
1628EFI_STATUS\r
1629EFIAPI\r
1630ConSplitterConOutDriverBindingStop (\r
1631 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
1632 IN EFI_HANDLE ControllerHandle,\r
1633 IN UINTN NumberOfChildren,\r
1634 IN EFI_HANDLE *ChildHandleBuffer\r
1635 )\r
1636{\r
1637 EFI_STATUS Status;\r
1638 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut;\r
1639\r
1640 if (NumberOfChildren == 0) {\r
1641 return EFI_SUCCESS;\r
1642 }\r
1643\r
1644 //\r
1645 // Close Absolute Pointer protocol on controller handle and virtual handle.\r
1646 //\r
1647 Status = ConSplitterStop (\r
1648 This,\r
1649 ControllerHandle,\r
1650 mConOut.VirtualHandle,\r
1651 &gEfiConsoleOutDeviceGuid,\r
1652 &gEfiSimpleTextOutProtocolGuid,\r
1653 (VOID **) &TextOut\r
1654 );\r
1655 if (EFI_ERROR (Status)) {\r
1656 return Status;\r
1657 }\r
1658\r
1659 //\r
1660 // Remove this device from Text Out device list.\r
1661 //\r
1662 return ConSplitterTextOutDeleteDevice (&mConOut, TextOut);\r
1663}\r
1664\r
1665\r
1666/**\r
1667 Stop Standard Error ConSplitter on ControllerHandle by closing Standard Error GUID.\r
1668\r
1669 @param This Driver Binding protocol instance pointer.\r
1670 @param ControllerHandle Handle of device to stop driver on\r
1671 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of\r
1672 children is zero stop the entire bus driver.\r
1673 @param ChildHandleBuffer List of Child Handles to Stop.\r
1674\r
1675 @retval EFI_SUCCESS This driver is removed ControllerHandle\r
1676 @retval other This driver was not removed from this device\r
1677\r
1678**/\r
1679EFI_STATUS\r
1680EFIAPI\r
1681ConSplitterStdErrDriverBindingStop (\r
1682 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
1683 IN EFI_HANDLE ControllerHandle,\r
1684 IN UINTN NumberOfChildren,\r
1685 IN EFI_HANDLE *ChildHandleBuffer\r
1686 )\r
1687{\r
1688 EFI_STATUS Status;\r
1689 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut;\r
1690\r
1691 if (NumberOfChildren == 0) {\r
1692 return EFI_SUCCESS;\r
1693 }\r
1694\r
1695 //\r
1696 // Close Standard Error Device on controller handle and virtual handle.\r
1697 //\r
1698 Status = ConSplitterStop (\r
1699 This,\r
1700 ControllerHandle,\r
1701 mStdErr.VirtualHandle,\r
1702 &gEfiStandardErrorDeviceGuid,\r
1703 &gEfiSimpleTextOutProtocolGuid,\r
1704 (VOID **) &TextOut\r
1705 );\r
1706 if (EFI_ERROR (Status)) {\r
1707 return Status;\r
1708 }\r
1709 //\r
1710 // Delete this console error out device's data structures.\r
1711 //\r
1712 Status = ConSplitterTextOutDeleteDevice (&mStdErr, TextOut);\r
1713 if (EFI_ERROR (Status)) {\r
1714 return Status;\r
1715 }\r
1716\r
1717 if (mStdErr.CurrentNumberOfConsoles == 0) {\r
1718 gST->StandardErrorHandle = NULL;\r
1719 gST->StdErr = NULL;\r
1720 //\r
1721 // Update the CRC32 in the EFI System Table header\r
1722 //\r
1723 gST->Hdr.CRC32 = 0;\r
1724 gBS->CalculateCrc32 (\r
1725 (UINT8 *) &gST->Hdr,\r
1726 gST->Hdr.HeaderSize,\r
1727 &gST->Hdr.CRC32\r
1728 );\r
1729 }\r
1730\r
1731 return Status;\r
1732}\r
1733\r
1734\r
1735/**\r
1736 Take the passed in Buffer of size SizeOfCount and grow the buffer\r
1737 by MAX (CONSOLE_SPLITTER_CONSOLES_ALLOC_UNIT, MaxGrow) * SizeOfCount\r
1738 bytes. Copy the current data in Buffer to the new version of Buffer\r
1739 and free the old version of buffer.\r
1740\r
1741 @param SizeOfCount Size of element in array.\r
1742 @param Count Current number of elements in array.\r
1743 @param Buffer Bigger version of passed in Buffer with all the\r
1744 data.\r
1745\r
1746 @retval EFI_SUCCESS Buffer size has grown.\r
1747 @retval EFI_OUT_OF_RESOURCES Could not grow the buffer size.\r
1748\r
1749**/\r
1750EFI_STATUS\r
1751ConSplitterGrowBuffer (\r
1752 IN UINTN SizeOfCount,\r
1753 IN UINTN *Count,\r
1754 IN OUT VOID **Buffer\r
1755 )\r
1756{\r
1757 VOID *Ptr;\r
1758\r
1759 //\r
1760 // grow the buffer to new buffer size,\r
1761 // copy the old buffer's content to the new-size buffer,\r
1762 // then free the old buffer.\r
1763 //\r
1764 *Count += CONSOLE_SPLITTER_CONSOLES_ALLOC_UNIT;\r
1765 Ptr = ReallocatePool (\r
1766 SizeOfCount * ((*Count) - CONSOLE_SPLITTER_CONSOLES_ALLOC_UNIT),\r
1767 SizeOfCount * (*Count),\r
1768 *Buffer\r
1769 );\r
1770 if (Ptr == NULL) {\r
1771 return EFI_OUT_OF_RESOURCES;\r
1772 }\r
1773 *Buffer = Ptr;\r
1774 return EFI_SUCCESS;\r
1775}\r
1776\r
1777\r
1778/**\r
1779 Add Text Input Device in Consplitter Text Input list.\r
1780\r
1781 @param Private Text In Splitter pointer.\r
1782 @param TextIn Simple Text Input protocol pointer.\r
1783\r
1784 @retval EFI_SUCCESS Text Input Device added successfully.\r
1785 @retval EFI_OUT_OF_RESOURCES Could not grow the buffer size.\r
1786\r
1787**/\r
1788EFI_STATUS\r
1789ConSplitterTextInAddDevice (\r
1790 IN TEXT_IN_SPLITTER_PRIVATE_DATA *Private,\r
1791 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *TextIn\r
1792 )\r
1793{\r
1794 EFI_STATUS Status;\r
1795\r
1796 //\r
1797 // If the Text In List is full, enlarge it by calling ConSplitterGrowBuffer().\r
1798 //\r
1799 if (Private->CurrentNumberOfConsoles >= Private->TextInListCount) {\r
1800 Status = ConSplitterGrowBuffer (\r
1801 sizeof (EFI_SIMPLE_TEXT_INPUT_PROTOCOL *),\r
1802 &Private->TextInListCount,\r
1803 (VOID **) &Private->TextInList\r
1804 );\r
1805 if (EFI_ERROR (Status)) {\r
1806 return EFI_OUT_OF_RESOURCES;\r
1807 }\r
1808 }\r
1809 //\r
1810 // Add the new text-in device data structure into the Text In List.\r
1811 //\r
1812 Private->TextInList[Private->CurrentNumberOfConsoles] = TextIn;\r
1813 Private->CurrentNumberOfConsoles++;\r
1814\r
1815 //\r
1816 // Extra CheckEvent added to reduce the double CheckEvent().\r
1817 //\r
1818 gBS->CheckEvent (TextIn->WaitForKey);\r
1819\r
1820 return EFI_SUCCESS;\r
1821}\r
1822\r
1823\r
1824/**\r
1825 Remove Text Input Device from Consplitter Text Input list.\r
1826\r
1827 @param Private Text In Splitter pointer.\r
1828 @param TextIn Simple Text protocol pointer.\r
1829\r
1830 @retval EFI_SUCCESS Simple Text Device removed successfully.\r
1831 @retval EFI_NOT_FOUND No Simple Text Device found.\r
1832\r
1833**/\r
1834EFI_STATUS\r
1835ConSplitterTextInDeleteDevice (\r
1836 IN TEXT_IN_SPLITTER_PRIVATE_DATA *Private,\r
1837 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *TextIn\r
1838 )\r
1839{\r
1840 UINTN Index;\r
1841 //\r
1842 // Remove the specified text-in device data structure from the Text In List,\r
1843 // and rearrange the remaining data structures in the Text In List.\r
1844 //\r
1845 for (Index = 0; Index < Private->CurrentNumberOfConsoles; Index++) {\r
1846 if (Private->TextInList[Index] == TextIn) {\r
1847 for (Index = Index; Index < Private->CurrentNumberOfConsoles - 1; Index++) {\r
1848 Private->TextInList[Index] = Private->TextInList[Index + 1];\r
1849 }\r
1850\r
1851 Private->CurrentNumberOfConsoles--;\r
1852 return EFI_SUCCESS;\r
1853 }\r
1854 }\r
1855\r
1856 return EFI_NOT_FOUND;\r
1857}\r
1858\r
1859/**\r
1860 Add Text Input Ex Device in Consplitter Text Input Ex list.\r
1861\r
1862 @param Private Text In Splitter pointer.\r
1863 @param TextInEx Simple Text Input Ex Input protocol pointer.\r
1864\r
1865 @retval EFI_SUCCESS Text Input Ex Device added successfully.\r
1866 @retval EFI_OUT_OF_RESOURCES Could not grow the buffer size.\r
1867\r
1868**/\r
1869EFI_STATUS\r
1870ConSplitterTextInExAddDevice (\r
1871 IN TEXT_IN_SPLITTER_PRIVATE_DATA *Private,\r
1872 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TextInEx\r
1873 )\r
1874{\r
1875 EFI_STATUS Status;\r
1876\r
1877 //\r
1878 // If the Text Input Ex List is full, enlarge it by calling ConSplitterGrowBuffer().\r
1879 //\r
1880 if (Private->CurrentNumberOfExConsoles >= Private->TextInExListCount) {\r
1881 Status = ConSplitterGrowBuffer (\r
1882 sizeof (EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *),\r
1883 &Private->TextInExListCount,\r
1884 (VOID **) &Private->TextInExList\r
1885 );\r
1886 if (EFI_ERROR (Status)) {\r
1887 return EFI_OUT_OF_RESOURCES;\r
1888 }\r
1889 }\r
1890 //\r
1891 // Add the new text-in device data structure into the Text Input Ex List.\r
1892 //\r
1893 Private->TextInExList[Private->CurrentNumberOfExConsoles] = TextInEx;\r
1894 Private->CurrentNumberOfExConsoles++;\r
1895\r
1896 //\r
1897 // Extra CheckEvent added to reduce the double CheckEvent().\r
1898 //\r
1899 gBS->CheckEvent (TextInEx->WaitForKeyEx);\r
1900\r
1901 return EFI_SUCCESS;\r
1902}\r
1903\r
1904/**\r
1905 Remove Text Ex Device from Consplitter Text Input Ex list.\r
1906\r
1907 @param Private Text In Splitter pointer.\r
1908 @param TextInEx Simple Text Ex protocol pointer.\r
1909\r
1910 @retval EFI_SUCCESS Simple Text Input Ex Device removed successfully.\r
1911 @retval EFI_NOT_FOUND No Simple Text Input Ex Device found.\r
1912\r
1913**/\r
1914EFI_STATUS\r
1915ConSplitterTextInExDeleteDevice (\r
1916 IN TEXT_IN_SPLITTER_PRIVATE_DATA *Private,\r
1917 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TextInEx\r
1918 )\r
1919{\r
1920 UINTN Index;\r
1921 //\r
1922 // Remove the specified text-in device data structure from the Text Input Ex List,\r
1923 // and rearrange the remaining data structures in the Text In List.\r
1924 //\r
1925 for (Index = 0; Index < Private->CurrentNumberOfExConsoles; Index++) {\r
1926 if (Private->TextInExList[Index] == TextInEx) {\r
1927 for (Index = Index; Index < Private->CurrentNumberOfExConsoles - 1; Index++) {\r
1928 Private->TextInExList[Index] = Private->TextInExList[Index + 1];\r
1929 }\r
1930\r
1931 Private->CurrentNumberOfExConsoles--;\r
1932 return EFI_SUCCESS;\r
1933 }\r
1934 }\r
1935\r
1936 return EFI_NOT_FOUND;\r
1937}\r
1938\r
1939\r
1940/**\r
1941 Add Simple Pointer Device in Consplitter Simple Pointer list.\r
1942\r
1943 @param Private Text In Splitter pointer.\r
1944 @param SimplePointer Simple Pointer protocol pointer.\r
1945\r
1946 @retval EFI_SUCCESS Simple Pointer Device added successfully.\r
1947 @retval EFI_OUT_OF_RESOURCES Could not grow the buffer size.\r
1948\r
1949**/\r
1950EFI_STATUS\r
1951ConSplitterSimplePointerAddDevice (\r
1952 IN TEXT_IN_SPLITTER_PRIVATE_DATA *Private,\r
1953 IN EFI_SIMPLE_POINTER_PROTOCOL *SimplePointer\r
1954 )\r
1955{\r
1956 EFI_STATUS Status;\r
1957\r
1958 //\r
1959 // If the Simple Pointer List is full, enlarge it by calling ConSplitterGrowBuffer().\r
1960 //\r
1961 if (Private->CurrentNumberOfPointers >= Private->PointerListCount) {\r
1962 Status = ConSplitterGrowBuffer (\r
1963 sizeof (EFI_SIMPLE_POINTER_PROTOCOL *),\r
1964 &Private->PointerListCount,\r
1965 (VOID **) &Private->PointerList\r
1966 );\r
1967 if (EFI_ERROR (Status)) {\r
1968 return EFI_OUT_OF_RESOURCES;\r
1969 }\r
1970 }\r
1971 //\r
1972 // Add the new text-in device data structure into the Simple Pointer List.\r
1973 //\r
1974 Private->PointerList[Private->CurrentNumberOfPointers] = SimplePointer;\r
1975 Private->CurrentNumberOfPointers++;\r
1976\r
1977 return EFI_SUCCESS;\r
1978}\r
1979\r
1980\r
1981/**\r
1982 Remove Simple Pointer Device from Consplitter Simple Pointer list.\r
1983\r
1984 @param Private Text In Splitter pointer.\r
1985 @param SimplePointer Simple Pointer protocol pointer.\r
1986\r
1987 @retval EFI_SUCCESS Simple Pointer Device removed successfully.\r
1988 @retval EFI_NOT_FOUND No Simple Pointer Device found.\r
1989\r
1990**/\r
1991EFI_STATUS\r
1992ConSplitterSimplePointerDeleteDevice (\r
1993 IN TEXT_IN_SPLITTER_PRIVATE_DATA *Private,\r
1994 IN EFI_SIMPLE_POINTER_PROTOCOL *SimplePointer\r
1995 )\r
1996{\r
1997 UINTN Index;\r
1998 //\r
1999 // Remove the specified text-in device data structure from the Simple Pointer List,\r
2000 // and rearrange the remaining data structures in the Text In List.\r
2001 //\r
2002 for (Index = 0; Index < Private->CurrentNumberOfPointers; Index++) {\r
2003 if (Private->PointerList[Index] == SimplePointer) {\r
2004 for (Index = Index; Index < Private->CurrentNumberOfPointers - 1; Index++) {\r
2005 Private->PointerList[Index] = Private->PointerList[Index + 1];\r
2006 }\r
2007\r
2008 Private->CurrentNumberOfPointers--;\r
2009 return EFI_SUCCESS;\r
2010 }\r
2011 }\r
2012\r
2013 return EFI_NOT_FOUND;\r
2014}\r
2015\r
2016\r
2017/**\r
2018 Add Absolute Pointer Device in Consplitter Absolute Pointer list.\r
2019\r
2020 @param Private Text In Splitter pointer.\r
2021 @param AbsolutePointer Absolute Pointer protocol pointer.\r
2022\r
2023 @retval EFI_SUCCESS Absolute Pointer Device added successfully.\r
2024 @retval EFI_OUT_OF_RESOURCES Could not grow the buffer size.\r
2025\r
2026**/\r
2027EFI_STATUS\r
2028ConSplitterAbsolutePointerAddDevice (\r
2029 IN TEXT_IN_SPLITTER_PRIVATE_DATA *Private,\r
2030 IN EFI_ABSOLUTE_POINTER_PROTOCOL *AbsolutePointer\r
2031 )\r
2032{\r
2033 EFI_STATUS Status;\r
2034\r
2035 //\r
2036 // If the Absolute Pointer List is full, enlarge it by calling ConSplitterGrowBuffer().\r
2037 //\r
2038 if (Private->CurrentNumberOfAbsolutePointers >= Private->AbsolutePointerListCount) {\r
2039 Status = ConSplitterGrowBuffer (\r
2040 sizeof (EFI_ABSOLUTE_POINTER_PROTOCOL *),\r
2041 &Private->AbsolutePointerListCount,\r
2042 (VOID **) &Private->AbsolutePointerList\r
2043 );\r
2044 if (EFI_ERROR (Status)) {\r
2045 return EFI_OUT_OF_RESOURCES;\r
2046 }\r
2047 }\r
2048 //\r
2049 // Add the new text-in device data structure into the Absolute Pointer List.\r
2050 //\r
2051 Private->AbsolutePointerList[Private->CurrentNumberOfAbsolutePointers] = AbsolutePointer;\r
2052 Private->CurrentNumberOfAbsolutePointers++;\r
2053\r
2054 return EFI_SUCCESS;\r
2055}\r
2056\r
2057\r
2058/**\r
2059 Remove Absolute Pointer Device from Consplitter Absolute Pointer list.\r
2060\r
2061 @param Private Text In Splitter pointer.\r
2062 @param AbsolutePointer Absolute Pointer protocol pointer.\r
2063\r
2064 @retval EFI_SUCCESS Absolute Pointer Device removed successfully.\r
2065 @retval EFI_NOT_FOUND No Absolute Pointer Device found.\r
2066\r
2067**/\r
2068EFI_STATUS\r
2069ConSplitterAbsolutePointerDeleteDevice (\r
2070 IN TEXT_IN_SPLITTER_PRIVATE_DATA *Private,\r
2071 IN EFI_ABSOLUTE_POINTER_PROTOCOL *AbsolutePointer\r
2072 )\r
2073{\r
2074 UINTN Index;\r
2075 //\r
2076 // Remove the specified text-in device data structure from the Absolute Pointer List,\r
2077 // and rearrange the remaining data structures from the Absolute Pointer List.\r
2078 //\r
2079 for (Index = 0; Index < Private->CurrentNumberOfAbsolutePointers; Index++) {\r
2080 if (Private->AbsolutePointerList[Index] == AbsolutePointer) {\r
2081 for (Index = Index; Index < Private->CurrentNumberOfAbsolutePointers - 1; Index++) {\r
2082 Private->AbsolutePointerList[Index] = Private->AbsolutePointerList[Index + 1];\r
2083 }\r
2084\r
2085 Private->CurrentNumberOfAbsolutePointers--;\r
2086 return EFI_SUCCESS;\r
2087 }\r
2088 }\r
2089\r
2090 return EFI_NOT_FOUND;\r
2091}\r
2092\r
2093/**\r
2094 Reallocate Text Out mode map.\r
2095\r
2096 Allocate new buffer and copy original buffer into the new buffer.\r
2097\r
2098 @param Private Consplitter Text Out pointer.\r
2099\r
2100 @retval EFI_SUCCESS Buffer size has grown\r
2101 @retval EFI_OUT_OF_RESOURCES Could not grow the buffer size.\r
2102\r
2103**/\r
2104EFI_STATUS\r
2105ConSplitterGrowMapTable (\r
2106 IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private\r
2107 )\r
2108{\r
2109 UINTN Size;\r
2110 UINTN NewSize;\r
2111 UINTN TotalSize;\r
2112 INT32 *TextOutModeMap;\r
2113 INT32 *OldTextOutModeMap;\r
2114 INT32 *SrcAddress;\r
2115 INT32 Index;\r
2116\r
2117 NewSize = Private->TextOutListCount * sizeof (INT32);\r
2118 OldTextOutModeMap = Private->TextOutModeMap;\r
2119 TotalSize = NewSize * (Private->TextOutQueryDataCount);\r
2120\r
2121 //\r
2122 // Allocate new buffer for Text Out List.\r
2123 //\r
2124 TextOutModeMap = AllocatePool (TotalSize);\r
2125 if (TextOutModeMap == NULL) {\r
2126 return EFI_OUT_OF_RESOURCES;\r
2127 }\r
2128\r
2129 SetMem (TextOutModeMap, TotalSize, 0xFF);\r
2130 Private->TextOutModeMap = TextOutModeMap;\r
2131\r
2132 //\r
2133 // If TextOutList has been enlarged, need to realloc the mode map table\r
2134 // The mode map table is regarded as a two dimension array.\r
2135 //\r
2136 // Old New\r
2137 // 0 ---------> TextOutListCount ----> TextOutListCount\r
2138 // | -------------------------------------------\r
2139 // | | | |\r
2140 // | | | |\r
2141 // | | | |\r
2142 // | | | |\r
2143 // | | | |\r
2144 // \/ | | |\r
2145 // -------------------------------------------\r
2146 // QueryDataCount\r
2147 //\r
2148 if (OldTextOutModeMap != NULL) {\r
2149\r
2150 Size = Private->CurrentNumberOfConsoles * sizeof (INT32);\r
2151 Index = 0;\r
2152 SrcAddress = OldTextOutModeMap;\r
2153\r
2154 //\r
2155 // Copy the old data to the new one\r
2156 //\r
2157 while (Index < Private->TextOutMode.MaxMode) {\r
2158 CopyMem (TextOutModeMap, SrcAddress, Size);\r
2159 TextOutModeMap += NewSize;\r
2160 SrcAddress += Size;\r
2161 Index++;\r
2162 }\r
2163 //\r
2164 // Free the old buffer\r
2165 //\r
2166 FreePool (OldTextOutModeMap);\r
2167 }\r
2168\r
2169 return EFI_SUCCESS;\r
2170}\r
2171\r
2172\r
2173/**\r
2174 Add new device's output mode to console splitter's mode list.\r
2175\r
2176 @param Private Text Out Splitter pointer\r
2177 @param TextOut Simple Text Output protocol pointer.\r
2178\r
2179 @retval EFI_SUCCESS Device added successfully.\r
2180 @retval EFI_OUT_OF_RESOURCES Could not grow the buffer size.\r
2181\r
2182**/\r
2183EFI_STATUS\r
2184ConSplitterAddOutputMode (\r
2185 IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private,\r
2186 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut\r
2187 )\r
2188{\r
2189 EFI_STATUS Status;\r
2190 INT32 MaxMode;\r
2191 INT32 Mode;\r
2192 UINTN Index;\r
2193\r
2194 MaxMode = TextOut->Mode->MaxMode;\r
2195 Private->TextOutMode.MaxMode = MaxMode;\r
2196\r
2197 //\r
2198 // Grow the buffer if query data buffer is not large enough to\r
2199 // hold all the mode supported by the first console.\r
2200 //\r
2201 while (MaxMode > (INT32) Private->TextOutQueryDataCount) {\r
2202 Status = ConSplitterGrowBuffer (\r
2203 sizeof (TEXT_OUT_SPLITTER_QUERY_DATA),\r
2204 &Private->TextOutQueryDataCount,\r
2205 (VOID **) &Private->TextOutQueryData\r
2206 );\r
2207 if (EFI_ERROR (Status)) {\r
2208 return EFI_OUT_OF_RESOURCES;\r
2209 }\r
2210 }\r
2211 //\r
2212 // Allocate buffer for the output mode map\r
2213 //\r
2214 Status = ConSplitterGrowMapTable (Private);\r
2215 if (EFI_ERROR (Status)) {\r
2216 return EFI_OUT_OF_RESOURCES;\r
2217 }\r
2218 //\r
2219 // As the first textout device, directly add the mode in to QueryData\r
2220 // and at the same time record the mapping between QueryData and TextOut.\r
2221 //\r
2222 Mode = 0;\r
2223 Index = 0;\r
2224 while (Mode < MaxMode) {\r
2225 Status = TextOut->QueryMode (\r
2226 TextOut,\r
2227 Mode,\r
2228 &Private->TextOutQueryData[Mode].Columns,\r
2229 &Private->TextOutQueryData[Mode].Rows\r
2230 );\r
2231 //\r
2232 // If mode 1 (80x50) is not supported, make sure mode 1 in TextOutQueryData\r
2233 // is clear to 0x0.\r
2234 //\r
2235 if ((EFI_ERROR(Status)) && (Mode == 1)) {\r
2236 Private->TextOutQueryData[Mode].Columns = 0;\r
2237 Private->TextOutQueryData[Mode].Rows = 0;\r
2238 }\r
2239 Private->TextOutModeMap[Index] = Mode;\r
2240 Mode++;\r
2241 Index += Private->TextOutListCount;\r
2242 }\r
2243\r
2244 return EFI_SUCCESS;\r
2245}\r
2246\r
2247/**\r
2248 Reconstruct TextOutModeMap to get intersection of modes.\r
2249\r
2250 This routine reconstruct TextOutModeMap to get the intersection\r
2251 of modes for all console out devices. Because EFI/UEFI spec require\r
2252 mode 0 is 80x25, mode 1 is 80x50, this routine will not check the\r
2253 intersection for mode 0 and mode 1.\r
2254\r
2255 @param TextOutModeMap Current text out mode map, begin with the mode 80x25\r
2256 @param NewlyAddedMap New text out mode map, begin with the mode 80x25\r
2257 @param MapStepSize Mode step size for one console device\r
2258 @param NewMapStepSize New Mode step size for one console device\r
2259 @param MaxMode IN: Current max text mode, OUT: Updated max text mode.\r
2260 @param CurrentMode IN: Current text mode, OUT: Updated current text mode.\r
2261\r
2262**/\r
2263VOID\r
2264ConSplitterGetIntersection (\r
2265 IN INT32 *TextOutModeMap,\r
2266 IN INT32 *NewlyAddedMap,\r
2267 IN UINTN MapStepSize,\r
2268 IN UINTN NewMapStepSize,\r
2269 IN OUT INT32 *MaxMode,\r
2270 IN OUT INT32 *CurrentMode\r
2271 )\r
2272{\r
2273 INT32 Index;\r
2274 INT32 *CurrentMapEntry;\r
2275 INT32 *NextMapEntry;\r
2276 INT32 *NewMapEntry;\r
2277 INT32 CurrentMaxMode;\r
2278 INT32 Mode;\r
2279\r
2280 //\r
2281 // According to EFI/UEFI spec, mode 0 and mode 1 have been reserved\r
2282 // for 80x25 and 80x50 in Simple Text Out protocol, so don't make intersection\r
2283 // for mode 0 and mode 1, mode number starts from 2.\r
2284 //\r
2285 Index = 2;\r
2286 CurrentMapEntry = &TextOutModeMap[MapStepSize * 2];\r
2287 NextMapEntry = CurrentMapEntry;\r
2288 NewMapEntry = &NewlyAddedMap[NewMapStepSize * 2];\r
2289\r
2290 CurrentMaxMode = *MaxMode;\r
2291 Mode = *CurrentMode;\r
2292\r
2293 while (Index < CurrentMaxMode) {\r
2294 if (*NewMapEntry == -1) {\r
2295 //\r
2296 // This mode is not supported any more. Remove it. Special care\r
2297 // must be taken as this remove will also affect current mode;\r
2298 //\r
2299 if (Index == *CurrentMode) {\r
2300 Mode = -1;\r
2301 } else if (Index < *CurrentMode) {\r
2302 Mode--;\r
2303 }\r
2304 (*MaxMode)--;\r
2305 } else {\r
2306 if (CurrentMapEntry != NextMapEntry) {\r
2307 CopyMem (NextMapEntry, CurrentMapEntry, MapStepSize * sizeof (INT32));\r
2308 }\r
2309\r
2310 NextMapEntry += MapStepSize;\r
2311 }\r
2312\r
2313 CurrentMapEntry += MapStepSize;\r
2314 NewMapEntry += NewMapStepSize;\r
2315 Index++;\r
2316 }\r
2317\r
2318 *CurrentMode = Mode;\r
2319\r
2320 return ;\r
2321}\r
2322\r
2323/**\r
2324 Sync the device's output mode to console splitter's mode list.\r
2325\r
2326 @param Private Text Out Splitter pointer.\r
2327 @param TextOut Simple Text Output protocol pointer.\r
2328\r
2329**/\r
2330VOID\r
2331ConSplitterSyncOutputMode (\r
2332 IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private,\r
2333 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut\r
2334 )\r
2335{\r
2336 INT32 CurrentMaxMode;\r
2337 INT32 Mode;\r
2338 INT32 Index;\r
2339 INT32 *TextOutModeMap;\r
2340 INT32 *MapTable;\r
2341 INT32 QueryMode;\r
2342 TEXT_OUT_SPLITTER_QUERY_DATA *TextOutQueryData;\r
2343 UINTN Rows;\r
2344 UINTN Columns;\r
2345 UINTN StepSize;\r
2346 EFI_STATUS Status;\r
2347\r
2348 //\r
2349 // Must make sure that current mode won't change even if mode number changes\r
2350 //\r
2351 CurrentMaxMode = Private->TextOutMode.MaxMode;\r
2352 TextOutModeMap = Private->TextOutModeMap;\r
2353 StepSize = Private->TextOutListCount;\r
2354 TextOutQueryData = Private->TextOutQueryData;\r
2355\r
2356 //\r
2357 // Query all the mode that the newly added TextOut supports\r
2358 //\r
2359 Mode = 0;\r
2360 MapTable = TextOutModeMap + Private->CurrentNumberOfConsoles;\r
2361 while (Mode < TextOut->Mode->MaxMode) {\r
2362 Status = TextOut->QueryMode (TextOut, Mode, &Columns, &Rows);\r
2363\r
2364 if (EFI_ERROR(Status)) {\r
2365 if (Mode == 1) {\r
2366 //\r
2367 // If mode 1 (80x50) is not supported, make sure mode 1 in TextOutQueryData\r
2368 // is clear to 0x0.\r
2369 //\r
2370 MapTable[StepSize] = Mode;\r
2371 TextOutQueryData[Mode].Columns = 0;\r
2372 TextOutQueryData[Mode].Rows = 0;\r
2373 }\r
2374 Mode++;\r
2375 continue;\r
2376 }\r
2377 //\r
2378 // Search the intersection map and QueryData database to see if they intersects\r
2379 //\r
2380 Index = 0;\r
2381 while (Index < CurrentMaxMode) {\r
2382 QueryMode = *(TextOutModeMap + Index * StepSize);\r
2383 if ((TextOutQueryData[QueryMode].Rows == Rows) && (TextOutQueryData[QueryMode].Columns == Columns)) {\r
2384 MapTable[Index * StepSize] = Mode;\r
2385 break;\r
2386 }\r
2387 Index++;\r
2388 }\r
2389 Mode++;\r
2390 }\r
2391 //\r
2392 // Now search the TextOutModeMap table to find the intersection of supported\r
2393 // mode between ConSplitter and the newly added device.\r
2394 //\r
2395 ConSplitterGetIntersection (\r
2396 TextOutModeMap,\r
2397 MapTable,\r
2398 StepSize,\r
2399 StepSize,\r
2400 &Private->TextOutMode.MaxMode,\r
2401 &Private->TextOutMode.Mode\r
2402 );\r
2403\r
2404 return ;\r
2405}\r
2406\r
2407\r
2408/**\r
2409 Sync output device between ConOut and StdErr output.\r
2410\r
2411 @retval EFI_SUCCESS Sync implemented successfully.\r
2412 @retval EFI_OUT_OF_RESOURCES Could not grow the buffer size.\r
2413\r
2414**/\r
2415EFI_STATUS\r
2416ConSplitterGetIntersectionBetweenConOutAndStrErr (\r
2417 VOID\r
2418 )\r
2419{\r
2420 UINTN ConOutNumOfConsoles;\r
2421 UINTN StdErrNumOfConsoles;\r
2422 TEXT_OUT_AND_GOP_DATA *ConOutTextOutList;\r
2423 TEXT_OUT_AND_GOP_DATA *StdErrTextOutList;\r
2424 UINTN Indexi;\r
2425 UINTN Indexj;\r
2426 UINTN ConOutRows;\r
2427 UINTN ConOutColumns;\r
2428 UINTN StdErrRows;\r
2429 UINTN StdErrColumns;\r
2430 INT32 ConOutMaxMode;\r
2431 INT32 StdErrMaxMode;\r
2432 INT32 ConOutMode;\r
2433 INT32 StdErrMode;\r
2434 INT32 Mode;\r
2435 INT32 Index;\r
2436 INT32 *ConOutModeMap;\r
2437 INT32 *StdErrModeMap;\r
2438 INT32 *ConOutMapTable;\r
2439 INT32 *StdErrMapTable;\r
2440 TEXT_OUT_SPLITTER_QUERY_DATA *ConOutQueryData;\r
2441 TEXT_OUT_SPLITTER_QUERY_DATA *StdErrQueryData;\r
2442 UINTN ConOutStepSize;\r
2443 UINTN StdErrStepSize;\r
2444 BOOLEAN FoundTheSameTextOut;\r
2445 UINTN ConOutMapTableSize;\r
2446 UINTN StdErrMapTableSize;\r
2447\r
2448 ConOutNumOfConsoles = mConOut.CurrentNumberOfConsoles;\r
2449 StdErrNumOfConsoles = mStdErr.CurrentNumberOfConsoles;\r
2450 ConOutTextOutList = mConOut.TextOutList;\r
2451 StdErrTextOutList = mStdErr.TextOutList;\r
2452\r
2453 Indexi = 0;\r
2454 FoundTheSameTextOut = FALSE;\r
2455 while ((Indexi < ConOutNumOfConsoles) && (!FoundTheSameTextOut)) {\r
2456 Indexj = 0;\r
2457 while (Indexj < StdErrNumOfConsoles) {\r
2458 if (ConOutTextOutList->TextOut == StdErrTextOutList->TextOut) {\r
2459 FoundTheSameTextOut = TRUE;\r
2460 break;\r
2461 }\r
2462\r
2463 Indexj++;\r
2464 StdErrTextOutList++;\r
2465 }\r
2466\r
2467 Indexi++;\r
2468 ConOutTextOutList++;\r
2469 }\r
2470\r
2471 if (!FoundTheSameTextOut) {\r
2472 return EFI_SUCCESS;\r
2473 }\r
2474 //\r
2475 // Must make sure that current mode won't change even if mode number changes\r
2476 //\r
2477 ConOutMaxMode = mConOut.TextOutMode.MaxMode;\r
2478 ConOutModeMap = mConOut.TextOutModeMap;\r
2479 ConOutStepSize = mConOut.TextOutListCount;\r
2480 ConOutQueryData = mConOut.TextOutQueryData;\r
2481\r
2482 StdErrMaxMode = mStdErr.TextOutMode.MaxMode;\r
2483 StdErrModeMap = mStdErr.TextOutModeMap;\r
2484 StdErrStepSize = mStdErr.TextOutListCount;\r
2485 StdErrQueryData = mStdErr.TextOutQueryData;\r
2486\r
2487 //\r
2488 // Allocate the map table and set the map table's index to -1.\r
2489 //\r
2490 ConOutMapTableSize = ConOutMaxMode * sizeof (INT32);\r
2491 ConOutMapTable = AllocateZeroPool (ConOutMapTableSize);\r
2492 if (ConOutMapTable == NULL) {\r
2493 return EFI_OUT_OF_RESOURCES;\r
2494 }\r
2495\r
2496 SetMem (ConOutMapTable, ConOutMapTableSize, 0xFF);\r
2497\r
2498 StdErrMapTableSize = StdErrMaxMode * sizeof (INT32);\r
2499 StdErrMapTable = AllocateZeroPool (StdErrMapTableSize);\r
2500 if (StdErrMapTable == NULL) {\r
2501 return EFI_OUT_OF_RESOURCES;\r
2502 }\r
2503\r
2504 SetMem (StdErrMapTable, StdErrMapTableSize, 0xFF);\r
2505\r
2506 //\r
2507 // Find the intersection of the two set of modes. If they actually intersect, the\r
2508 // correponding entry in the map table is set to 1.\r
2509 //\r
2510 Mode = 0;\r
2511 while (Mode < ConOutMaxMode) {\r
2512 //\r
2513 // Search the intersection map and QueryData database to see if they intersect\r
2514 //\r
2515 Index = 0;\r
2516 ConOutMode = *(ConOutModeMap + Mode * ConOutStepSize);\r
2517 ConOutRows = ConOutQueryData[ConOutMode].Rows;\r
2518 ConOutColumns = ConOutQueryData[ConOutMode].Columns;\r
2519 while (Index < StdErrMaxMode) {\r
2520 StdErrMode = *(StdErrModeMap + Index * StdErrStepSize);\r
2521 StdErrRows = StdErrQueryData[StdErrMode].Rows;\r
2522 StdErrColumns = StdErrQueryData[StdErrMode].Columns;\r
2523 if ((StdErrRows == ConOutRows) && (StdErrColumns == ConOutColumns)) {\r
2524 ConOutMapTable[Mode] = 1;\r
2525 StdErrMapTable[Index] = 1;\r
2526 break;\r
2527 }\r
2528\r
2529 Index++;\r
2530 }\r
2531\r
2532 Mode++;\r
2533 }\r
2534 //\r
2535 // Now search the TextOutModeMap table to find the intersection of supported\r
2536 // mode between ConSplitter and the newly added device.\r
2537 //\r
2538 ConSplitterGetIntersection (\r
2539 ConOutModeMap,\r
2540 ConOutMapTable,\r
2541 mConOut.TextOutListCount,\r
2542 1,\r
2543 &(mConOut.TextOutMode.MaxMode),\r
2544 &(mConOut.TextOutMode.Mode)\r
2545 );\r
2546\r
2547 if (mConOut.TextOutMode.Mode < 0) {\r
2548 mConOut.TextOut.SetMode (&(mConOut.TextOut), 0);\r
2549 }\r
2550\r
2551 ConSplitterGetIntersection (\r
2552 StdErrModeMap,\r
2553 StdErrMapTable,\r
2554 mStdErr.TextOutListCount,\r
2555 1,\r
2556 &(mStdErr.TextOutMode.MaxMode),\r
2557 &(mStdErr.TextOutMode.Mode)\r
2558 );\r
2559\r
2560 if (mStdErr.TextOutMode.Mode < 0) {\r
2561 mStdErr.TextOut.SetMode (&(mStdErr.TextOut), 0);\r
2562 }\r
2563\r
2564 FreePool (ConOutMapTable);\r
2565 FreePool (StdErrMapTable);\r
2566\r
2567 return EFI_SUCCESS;\r
2568}\r
2569\r
2570\r
2571/**\r
2572 Add Grahpics Output modes into Consplitter Text Out list.\r
2573\r
2574 @param Private Text Out Splitter pointer.\r
2575 @param GraphicsOutput Graphics Output protocol pointer.\r
2576 @param UgaDraw UGA Draw protocol pointer.\r
2577\r
2578 @retval EFI_SUCCESS Output mode added successfully.\r
2579 @retval other Failed to add output mode.\r
2580\r
2581**/\r
2582EFI_STATUS\r
2583ConSplitterAddGraphicsOutputMode (\r
2584 IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private,\r
2585 IN EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput,\r
2586 IN EFI_UGA_DRAW_PROTOCOL *UgaDraw\r
2587 )\r
2588{\r
2589 EFI_STATUS Status;\r
2590 UINTN Index;\r
2591 UINTN CurrentIndex;\r
2592 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Mode;\r
2593 UINTN SizeOfInfo;\r
2594 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;\r
2595 EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE *CurrentGraphicsOutputMode;\r
2596 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *ModeBuffer;\r
2597 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *MatchedMode;\r
2598 UINTN NumberIndex;\r
2599 BOOLEAN Match;\r
2600 BOOLEAN AlreadyExist;\r
2601 UINT32 UgaHorizontalResolution;\r
2602 UINT32 UgaVerticalResolution;\r
2603 UINT32 UgaColorDepth;\r
2604 UINT32 UgaRefreshRate;\r
2605\r
2606 ASSERT (GraphicsOutput != NULL || UgaDraw != NULL);\r
2607\r
2608 CurrentGraphicsOutputMode = Private->GraphicsOutput.Mode;\r
2609\r
2610 Index = 0;\r
2611 CurrentIndex = 0;\r
2612\r
2613 if (Private->CurrentNumberOfUgaDraw != 0) {\r
2614 //\r
2615 // If any UGA device has already been added, then there is no need to\r
2616 // calculate intersection of display mode of different GOP/UGA device,\r
2617 // since only one display mode will be exported (i.e. user-defined mode)\r
2618 //\r
2619 goto Done;\r
2620 }\r
2621\r
2622 if (GraphicsOutput != NULL) {\r
2623 if (Private->CurrentNumberOfGraphicsOutput == 0) {\r
2624 //\r
2625 // This is the first Graphics Output device added\r
2626 //\r
2627 CurrentGraphicsOutputMode->MaxMode = GraphicsOutput->Mode->MaxMode;\r
2628 CurrentGraphicsOutputMode->Mode = GraphicsOutput->Mode->Mode;\r
2629 CopyMem (CurrentGraphicsOutputMode->Info, GraphicsOutput->Mode->Info, GraphicsOutput->Mode->SizeOfInfo);\r
2630 CurrentGraphicsOutputMode->SizeOfInfo = GraphicsOutput->Mode->SizeOfInfo;\r
2631 CurrentGraphicsOutputMode->FrameBufferBase = GraphicsOutput->Mode->FrameBufferBase;\r
2632 CurrentGraphicsOutputMode->FrameBufferSize = GraphicsOutput->Mode->FrameBufferSize;\r
2633 \r
2634 //\r
2635 // Allocate resource for the private mode buffer\r
2636 //\r
2637 ModeBuffer = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION) * GraphicsOutput->Mode->MaxMode);\r
2638 if (ModeBuffer == NULL) {\r
2639 return EFI_OUT_OF_RESOURCES;\r
2640 }\r
2641 FreePool (Private->GraphicsOutputModeBuffer);\r
2642 Private->GraphicsOutputModeBuffer = ModeBuffer;\r
2643\r
2644 //\r
2645 // Store all supported display modes to the private mode buffer\r
2646 //\r
2647 Mode = ModeBuffer;\r
2648 for (Index = 0; Index < GraphicsOutput->Mode->MaxMode; Index++) {\r
2649 //\r
2650 // The Info buffer would be allocated by callee\r
2651 //\r
2652 Status = GraphicsOutput->QueryMode (GraphicsOutput, (UINT32) Index, &SizeOfInfo, &Info);\r
2653 if (EFI_ERROR (Status)) {\r
2654 return Status;\r
2655 }\r
2656 ASSERT ( SizeOfInfo <= sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));\r
2657 CopyMem (Mode, Info, SizeOfInfo);\r
2658 Mode++;\r
2659 FreePool (Info);\r
2660 }\r
2661 } else {\r
2662 //\r
2663 // Check intersection of display mode\r
2664 //\r
2665 ModeBuffer = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION) * CurrentGraphicsOutputMode->MaxMode);\r
2666 if (ModeBuffer == NULL) {\r
2667 return EFI_OUT_OF_RESOURCES;\r
2668 }\r
2669\r
2670 MatchedMode = ModeBuffer;\r
2671 Mode = &Private->GraphicsOutputModeBuffer[0];\r
2672 for (Index = 0; Index < CurrentGraphicsOutputMode->MaxMode; Index++) {\r
2673 Match = FALSE;\r
2674\r
2675 for (NumberIndex = 0; NumberIndex < GraphicsOutput->Mode->MaxMode; NumberIndex++) {\r
2676 //\r
2677 // The Info buffer would be allocated by callee\r
2678 //\r
2679 Status = GraphicsOutput->QueryMode (GraphicsOutput, (UINT32) NumberIndex, &SizeOfInfo, &Info);\r
2680 if (EFI_ERROR (Status)) {\r
2681 return Status;\r
2682 }\r
2683 if ((Info->HorizontalResolution == Mode->HorizontalResolution) &&\r
2684 (Info->VerticalResolution == Mode->VerticalResolution)) {\r
2685 //\r
2686 // If GOP device supports one mode in current mode buffer,\r
2687 // it will be added into matched mode buffer\r
2688 //\r
2689 Match = TRUE;\r
2690 FreePool (Info);\r
2691 break;\r
2692 }\r
2693 FreePool (Info);\r
2694 }\r
2695\r
2696 if (Match) {\r
2697 AlreadyExist = FALSE;\r
2698\r
2699 //\r
2700 // Check if GOP mode has been in the mode buffer, ModeBuffer = MatchedMode at begin.\r
2701 //\r
2702 for (Info = ModeBuffer; Info < MatchedMode; Info++) {\r
2703 if ((Info->HorizontalResolution == Mode->HorizontalResolution) &&\r
2704 (Info->VerticalResolution == Mode->VerticalResolution)) {\r
2705 AlreadyExist = TRUE;\r
2706 break;\r
2707 }\r
2708 }\r
2709\r
2710 if (!AlreadyExist) {\r
2711 CopyMem (MatchedMode, Mode, sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));\r
2712\r
2713 //\r
2714 // Physical frame buffer is no longer available, change PixelFormat to PixelBltOnly\r
2715 //\r
2716 MatchedMode->Version = 0;\r
2717 MatchedMode->PixelFormat = PixelBltOnly;\r
2718 ZeroMem (&MatchedMode->PixelInformation, sizeof (EFI_PIXEL_BITMASK));\r
2719\r
2720 MatchedMode++;\r
2721 }\r
2722 }\r
2723\r
2724 Mode++;\r
2725 }\r
2726\r
2727 //\r
2728 // Drop the old mode buffer, assign it to a new one\r
2729 //\r
2730 FreePool (Private->GraphicsOutputModeBuffer);\r
2731 Private->GraphicsOutputModeBuffer = ModeBuffer;\r
2732\r
2733 //\r
2734 // Physical frame buffer is no longer available when there are more than one physical GOP devices\r
2735 //\r
2736 CurrentGraphicsOutputMode->MaxMode = (UINT32) (((UINTN) MatchedMode - (UINTN) ModeBuffer) / sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));\r
2737 CurrentGraphicsOutputMode->Info->PixelFormat = PixelBltOnly;\r
2738 ZeroMem (&CurrentGraphicsOutputMode->Info->PixelInformation, sizeof (EFI_PIXEL_BITMASK));\r
2739 CurrentGraphicsOutputMode->SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);\r
2740 CurrentGraphicsOutputMode->FrameBufferBase = (EFI_PHYSICAL_ADDRESS) (UINTN) NULL;\r
2741 CurrentGraphicsOutputMode->FrameBufferSize = 0;\r
2742 }\r
2743\r
2744 //\r
2745 // Graphics console driver can ensure the same mode for all GOP devices\r
2746 //\r
2747 for (Index = 0; Index < CurrentGraphicsOutputMode->MaxMode; Index++) {\r
2748 Mode = &Private->GraphicsOutputModeBuffer[Index];\r
2749 if ((Mode->HorizontalResolution == GraphicsOutput->Mode->Info->HorizontalResolution) &&\r
2750 (Mode->VerticalResolution == GraphicsOutput->Mode->Info->VerticalResolution)) {\r
2751 CurrentIndex = Index;\r
2752 break;\r
2753 }\r
2754 }\r
2755 if (Index >= CurrentGraphicsOutputMode->MaxMode) {\r
2756 //\r
2757 // if user defined mode is not found, set to default mode 800x600\r
2758 //\r
2759 for (Index = 0; Index < CurrentGraphicsOutputMode->MaxMode; Index++) {\r
2760 Mode = &Private->GraphicsOutputModeBuffer[Index];\r
2761 if ((Mode->HorizontalResolution == 800) && (Mode->VerticalResolution == 600)) {\r
2762 CurrentIndex = Index;\r
2763 break;\r
2764 }\r
2765 }\r
2766 }\r
2767 } else if (UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {\r
2768 //\r
2769 // Graphics console driver can ensure the same mode for all GOP devices\r
2770 // so we can get the current mode from this video device\r
2771 //\r
2772 UgaDraw->GetMode (\r
2773 UgaDraw,\r
2774 &UgaHorizontalResolution,\r
2775 &UgaVerticalResolution,\r
2776 &UgaColorDepth,\r
2777 &UgaRefreshRate\r
2778 );\r
2779\r
2780 CurrentGraphicsOutputMode->MaxMode = 1;\r
2781 Info = CurrentGraphicsOutputMode->Info;\r
2782 Info->Version = 0;\r
2783 Info->HorizontalResolution = UgaHorizontalResolution;\r
2784 Info->VerticalResolution = UgaVerticalResolution;\r
2785 Info->PixelFormat = PixelBltOnly;\r
2786 Info->PixelsPerScanLine = UgaHorizontalResolution;\r
2787 CurrentGraphicsOutputMode->SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);\r
2788 CurrentGraphicsOutputMode->FrameBufferBase = (EFI_PHYSICAL_ADDRESS) (UINTN) NULL;\r
2789 CurrentGraphicsOutputMode->FrameBufferSize = 0;\r
2790\r
2791 //\r
2792 // Update the private mode buffer\r
2793 //\r
2794 CopyMem (&Private->GraphicsOutputModeBuffer[0], Info, sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));\r
2795\r
2796 //\r
2797 // Only mode 0 is available to be set\r
2798 //\r
2799 CurrentIndex = 0;\r
2800 }\r
2801\r
2802Done:\r
2803\r
2804 if (GraphicsOutput != NULL) {\r
2805 Private->CurrentNumberOfGraphicsOutput++;\r
2806 }\r
2807 if (UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {\r
2808 Private->CurrentNumberOfUgaDraw++;\r
2809 }\r
2810\r
2811 //\r
2812 // Force GraphicsOutput mode to be set,\r
2813 // regardless whether the console is in EfiConsoleControlScreenGraphics or EfiConsoleControlScreenText mode\r
2814 //\r
2815 Private->HardwareNeedsStarting = TRUE;\r
2816 //\r
2817 // Current mode number may need update now, so set it to an invalid mode number\r
2818 //\r
2819 CurrentGraphicsOutputMode->Mode = 0xffff;\r
2820 //\r
2821 // Graphics console can ensure all GOP devices have the same mode which can be taken as current mode.\r
2822 //\r
2823 Status = Private->GraphicsOutput.SetMode (&Private->GraphicsOutput, (UINT32) CurrentIndex);\r
2824 if (EFI_ERROR(Status)) {\r
2825 //\r
2826 // If user defined mode is not valid for display device, set to the default mode 800x600.\r
2827 //\r
2828 (Private->GraphicsOutputModeBuffer[0]).HorizontalResolution = 800;\r
2829 (Private->GraphicsOutputModeBuffer[0]).VerticalResolution = 600;\r
2830 Status = Private->GraphicsOutput.SetMode (&Private->GraphicsOutput, 0);\r
2831 }\r
2832\r
2833 return Status;\r
2834}\r
2835\r
2836/**\r
2837 Set the current console out mode.\r
2838\r
2839 This routine will get the current console mode information (column, row)\r
2840 from ConsoleOutMode variable and set it; if the variable does not exist,\r
2841 set to user defined console mode.\r
2842\r
2843 @param Private Consplitter Text Out pointer.\r
2844\r
2845**/\r
2846VOID\r
2847ConsplitterSetConsoleOutMode (\r
2848 IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private\r
2849 )\r
2850{\r
2851 UINTN Col;\r
2852 UINTN Row;\r
2853 UINTN Mode;\r
2854 UINTN PreferMode;\r
2855 UINTN BaseMode;\r
2856 UINTN MaxMode;\r
2857 EFI_STATUS Status;\r
2858 CONSOLE_OUT_MODE ModeInfo;\r
2859 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut;\r
2860\r
2861 PreferMode = 0xFF;\r
2862 BaseMode = 0xFF;\r
2863 TextOut = &Private->TextOut;\r
2864 MaxMode = (UINTN) (TextOut->Mode->MaxMode);\r
2865\r
2866 ModeInfo.Column = PcdGet32 (PcdConOutColumn);\r
2867 ModeInfo.Row = PcdGet32 (PcdConOutRow);\r
2868\r
2869 //\r
2870 // To find the prefer mode and basic mode from Text Out mode list\r
2871 //\r
2872 for (Mode = 0; Mode < MaxMode; Mode++) {\r
2873 Status = TextOut->QueryMode (TextOut, Mode, &Col, &Row);\r
2874 if (!EFI_ERROR(Status)) {\r
2875 if (Col == ModeInfo.Column && Row == ModeInfo.Row) {\r
2876 PreferMode = Mode;\r
2877 }\r
2878 if (Col == 80 && Row == 25) {\r
2879 BaseMode = Mode;\r
2880 }\r
2881 }\r
2882 }\r
2883\r
2884 //\r
2885 // Set prefer mode to Text Out devices.\r
2886 //\r
2887 Status = TextOut->SetMode (TextOut, PreferMode);\r
2888 if (EFI_ERROR(Status)) {\r
2889 //\r
2890 // if current mode setting is failed, default 80x25 mode will be set.\r
2891 //\r
2892 Status = TextOut->SetMode (TextOut, BaseMode);\r
2893 ASSERT(!EFI_ERROR(Status));\r
2894 \r
2895 PcdSet32 (PcdConOutColumn, 80);\r
2896 PcdSet32 (PcdConOutRow, 25);\r
2897 }\r
2898\r
2899 return ;\r
2900}\r
2901\r
2902\r
2903/**\r
2904 Add Text Output Device in Consplitter Text Output list.\r
2905\r
2906 @param Private Text Out Splitter pointer.\r
2907 @param TextOut Simple Text Output protocol pointer.\r
2908 @param GraphicsOutput Graphics Output protocol pointer.\r
2909 @param UgaDraw UGA Draw protocol pointer.\r
2910\r
2911 @retval EFI_SUCCESS Text Output Device added successfully.\r
2912 @retval EFI_OUT_OF_RESOURCES Could not grow the buffer size.\r
2913\r
2914**/\r
2915EFI_STATUS\r
2916ConSplitterTextOutAddDevice (\r
2917 IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private,\r
2918 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut,\r
2919 IN EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput,\r
2920 IN EFI_UGA_DRAW_PROTOCOL *UgaDraw\r
2921 )\r
2922{\r
2923 EFI_STATUS Status;\r
2924 UINTN CurrentNumOfConsoles;\r
2925 INT32 MaxMode;\r
2926 UINT32 UgaHorizontalResolution;\r
2927 UINT32 UgaVerticalResolution;\r
2928 UINT32 UgaColorDepth;\r
2929 UINT32 UgaRefreshRate;\r
2930 TEXT_OUT_AND_GOP_DATA *TextAndGop;\r
2931 UINTN SizeOfInfo;\r
2932 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;\r
2933\r
2934 Status = EFI_SUCCESS;\r
2935 CurrentNumOfConsoles = Private->CurrentNumberOfConsoles;\r
2936\r
2937 //\r
2938 // If the Text Out List is full, enlarge it by calling ConSplitterGrowBuffer().\r
2939 //\r
2940 while (CurrentNumOfConsoles >= Private->TextOutListCount) {\r
2941 Status = ConSplitterGrowBuffer (\r
2942 sizeof (TEXT_OUT_AND_GOP_DATA),\r
2943 &Private->TextOutListCount,\r
2944 (VOID **) &Private->TextOutList\r
2945 );\r
2946 if (EFI_ERROR (Status)) {\r
2947 return EFI_OUT_OF_RESOURCES;\r
2948 }\r
2949 //\r
2950 // Also need to reallocate the TextOutModeMap table\r
2951 //\r
2952 Status = ConSplitterGrowMapTable (Private);\r
2953 if (EFI_ERROR (Status)) {\r
2954 return EFI_OUT_OF_RESOURCES;\r
2955 }\r
2956 }\r
2957\r
2958 TextAndGop = &Private->TextOutList[CurrentNumOfConsoles];\r
2959\r
2960 TextAndGop->TextOut = TextOut;\r
2961 TextAndGop->GraphicsOutput = GraphicsOutput;\r
2962 TextAndGop->UgaDraw = UgaDraw;\r
2963\r
2964 if (CurrentNumOfConsoles == 0) {\r
2965 //\r
2966 // Add the first device's output mode to console splitter's mode list\r
2967 //\r
2968 Status = ConSplitterAddOutputMode (Private, TextOut);\r
2969 } else {\r
2970 ConSplitterSyncOutputMode (Private, TextOut);\r
2971 }\r
2972\r
2973 Private->CurrentNumberOfConsoles++;\r
2974\r
2975 //\r
2976 // Scan both TextOutList, for the intersection TextOut device\r
2977 // maybe both ConOut and StdErr incorporate the same Text Out\r
2978 // device in them, thus the output of both should be synced.\r
2979 //\r
2980 ConSplitterGetIntersectionBetweenConOutAndStrErr ();\r
2981\r
2982 MaxMode = Private->TextOutMode.MaxMode;\r
2983 ASSERT (MaxMode >= 1);\r
2984\r
2985 if (FeaturePcdGet (PcdConOutGopSupport)) {\r
2986 //\r
2987 // If GOP is produced by Consplitter, this device display mode will be added into Graphics Ouput modes.\r
2988 //\r
2989 if ((GraphicsOutput != NULL) || (UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport))) {\r
2990 ConSplitterAddGraphicsOutputMode (Private, GraphicsOutput, UgaDraw);\r
2991 }\r
2992 }\r
2993\r
2994 if (FeaturePcdGet (PcdConOutUgaSupport)) {\r
2995 UgaHorizontalResolution = 800;\r
2996 UgaVerticalResolution = 600;\r
2997 UgaColorDepth = 32;\r
2998 UgaRefreshRate = 60;\r
2999\r
3000 Status = EFI_DEVICE_ERROR;\r
3001 //\r
3002 // If UGA is produced by Consplitter\r
3003 //\r
3004 if (GraphicsOutput != NULL) {\r
3005 Status = GraphicsOutput->QueryMode (GraphicsOutput, GraphicsOutput->Mode->Mode, &SizeOfInfo, &Info);\r
3006 if (EFI_ERROR (Status)) {\r
3007 return Status;\r
3008 }\r
3009 ASSERT ( SizeOfInfo <= sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));\r
3010\r
3011 UgaHorizontalResolution = Info->HorizontalResolution;\r
3012 UgaVerticalResolution = Info->VerticalResolution;\r
3013\r
3014 FreePool (Info);\r
3015\r
3016 } else if (UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {\r
3017 Status = UgaDraw->GetMode (\r
3018 UgaDraw,\r
3019 &UgaHorizontalResolution,\r
3020 &UgaVerticalResolution,\r
3021 &UgaColorDepth,\r
3022 &UgaRefreshRate\r
3023 );\r
3024 }\r
3025\r
3026 //\r
3027 // Set UGA Draw mode,\r
3028 // if GetMode is failed, set to 800x600 mode\r
3029 //\r
3030 Status = ConSpliterUgaDrawSetMode (\r
3031 &Private->UgaDraw,\r
3032 UgaHorizontalResolution,\r
3033 UgaVerticalResolution,\r
3034 UgaColorDepth,\r
3035 UgaRefreshRate\r
3036 );\r
3037 }\r
3038\r
3039 //\r
3040 // If ConOut, then set the mode to Mode #0 which us 80 x 25\r
3041 //\r
3042 Private->TextOut.SetMode (&Private->TextOut, 0);\r
3043\r
3044 //\r
3045 // After adding new console device, all existing console devices should be\r
3046 // synced to the current shared mode.\r
3047 //\r
3048 ConsplitterSetConsoleOutMode (Private);\r
3049\r
3050 return Status;\r
3051}\r
3052\r
3053\r
3054/**\r
3055 Remove Text Out Device in Consplitter Text Out list.\r
3056\r
3057 @param Private Text Out Splitter pointer.\r
3058 @param TextOut Simple Text Output Pointer protocol pointer.\r
3059\r
3060 @retval EFI_SUCCESS Text Out Device removed successfully.\r
3061 @retval EFI_NOT_FOUND No Text Out Device found.\r
3062\r
3063**/\r
3064EFI_STATUS\r
3065ConSplitterTextOutDeleteDevice (\r
3066 IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private,\r
3067 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut\r
3068 )\r
3069{\r
3070 INT32 Index;\r
3071 UINTN CurrentNumOfConsoles;\r
3072 TEXT_OUT_AND_GOP_DATA *TextOutList;\r
3073 EFI_STATUS Status;\r
3074\r
3075 //\r
3076 // Remove the specified text-out device data structure from the Text out List,\r
3077 // and rearrange the remaining data structures in the Text out List.\r
3078 //\r
3079 CurrentNumOfConsoles = Private->CurrentNumberOfConsoles;\r
3080 Index = (INT32) CurrentNumOfConsoles - 1;\r
3081 TextOutList = Private->TextOutList;\r
3082 while (Index >= 0) {\r
3083 if (TextOutList->TextOut == TextOut) {\r
3084 CopyMem (TextOutList, TextOutList + 1, sizeof (TEXT_OUT_AND_GOP_DATA) * Index);\r
3085 CurrentNumOfConsoles--;\r
3086 if (TextOutList->UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {\r
3087 Private->CurrentNumberOfUgaDraw--;\r
3088 }\r
3089 if (TextOutList->GraphicsOutput != NULL) {\r
3090 Private->CurrentNumberOfGraphicsOutput--;\r
3091 }\r
3092 break;\r
3093 }\r
3094\r
3095 Index--;\r
3096 TextOutList++;\r
3097 }\r
3098 //\r
3099 // The specified TextOut is not managed by the ConSplitter driver\r
3100 //\r
3101 if (Index < 0) {\r
3102 return EFI_NOT_FOUND;\r
3103 }\r
3104\r
3105 if (CurrentNumOfConsoles == 0) {\r
3106 //\r
3107 // If the number of consoles is zero, reset all parameters\r
3108 //\r
3109 Private->CurrentNumberOfConsoles = 0;\r
3110 Private->TextOutMode.MaxMode = 1;\r
3111 Private->TextOutQueryData[0].Columns = 80;\r
3112 Private->TextOutQueryData[0].Rows = 25;\r
3113 TextOutSetMode (Private, 0);\r
3114\r
3115 return EFI_SUCCESS;\r
3116 }\r
3117 //\r
3118 // Max Mode is realy an intersection of the QueryMode command to all\r
3119 // devices. So we must copy the QueryMode of the first device to\r
3120 // QueryData.\r
3121 //\r
3122 ZeroMem (\r
3123 Private->TextOutQueryData,\r
3124 Private->TextOutQueryDataCount * sizeof (TEXT_OUT_SPLITTER_QUERY_DATA)\r
3125 );\r
3126\r
3127 FreePool (Private->TextOutModeMap);\r
3128 Private->TextOutModeMap = NULL;\r
3129 TextOutList = Private->TextOutList;\r
3130\r
3131 //\r
3132 // Add the first TextOut to the QueryData array and ModeMap table\r
3133 //\r
3134 Status = ConSplitterAddOutputMode (Private, TextOutList->TextOut);\r
3135\r
3136 //\r
3137 // Now add one by one\r
3138 //\r
3139 Index = 1;\r
3140 Private->CurrentNumberOfConsoles = 1;\r
3141 TextOutList++;\r
3142 while ((UINTN) Index < CurrentNumOfConsoles) {\r
3143 ConSplitterSyncOutputMode (Private, TextOutList->TextOut);\r
3144 Index++;\r
3145 Private->CurrentNumberOfConsoles++;\r
3146 TextOutList++;\r
3147 }\r
3148\r
3149 ConSplitterGetIntersectionBetweenConOutAndStrErr ();\r
3150\r
3151 return Status;\r
3152}\r
3153\r
3154\r
3155/**\r
3156 Reset the input device and optionaly run diagnostics\r
3157\r
3158 @param This Protocol instance pointer.\r
3159 @param ExtendedVerification Driver may perform diagnostics on reset.\r
3160\r
3161 @retval EFI_SUCCESS The device was reset.\r
3162 @retval EFI_DEVICE_ERROR The device is not functioning properly and could\r
3163 not be reset.\r
3164\r
3165**/\r
3166EFI_STATUS\r
3167EFIAPI\r
3168ConSplitterTextInReset (\r
3169 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,\r
3170 IN BOOLEAN ExtendedVerification\r
3171 )\r
3172{\r
3173 EFI_STATUS Status;\r
3174 EFI_STATUS ReturnStatus;\r
3175 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3176 UINTN Index;\r
3177\r
3178 Private = TEXT_IN_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
3179\r
3180 Private->KeyEventSignalState = FALSE;\r
3181\r
3182 //\r
3183 // return the worst status met\r
3184 //\r
3185 for (Index = 0, ReturnStatus = EFI_SUCCESS; Index < Private->CurrentNumberOfConsoles; Index++) {\r
3186 Status = Private->TextInList[Index]->Reset (\r
3187 Private->TextInList[Index],\r
3188 ExtendedVerification\r
3189 );\r
3190 if (EFI_ERROR (Status)) {\r
3191 ReturnStatus = Status;\r
3192 }\r
3193 }\r
3194\r
3195 return ReturnStatus;\r
3196}\r
3197\r
3198\r
3199/**\r
3200 Reads the next keystroke from the input device. The WaitForKey Event can\r
3201 be used to test for existance of a keystroke via WaitForEvent () call.\r
3202\r
3203 @param Private Protocol instance pointer.\r
3204 @param Key Driver may perform diagnostics on reset.\r
3205\r
3206 @retval EFI_SUCCESS The keystroke information was returned.\r
3207 @retval EFI_NOT_READY There was no keystroke data availiable.\r
3208 @retval EFI_DEVICE_ERROR The keydtroke information was not returned due\r
3209 to hardware errors.\r
3210\r
3211**/\r
3212EFI_STATUS\r
3213EFIAPI\r
3214ConSplitterTextInPrivateReadKeyStroke (\r
3215 IN TEXT_IN_SPLITTER_PRIVATE_DATA *Private,\r
3216 OUT EFI_INPUT_KEY *Key\r
3217 )\r
3218{\r
3219 EFI_STATUS Status;\r
3220 UINTN Index;\r
3221 EFI_INPUT_KEY CurrentKey;\r
3222\r
3223 Key->UnicodeChar = 0;\r
3224 Key->ScanCode = SCAN_NULL;\r
3225\r
3226 //\r
3227 // if no physical console input device exists, return EFI_NOT_READY;\r
3228 // if any physical console input device has key input,\r
3229 // return the key and EFI_SUCCESS.\r
3230 //\r
3231 for (Index = 0; Index < Private->CurrentNumberOfConsoles; Index++) {\r
3232 Status = Private->TextInList[Index]->ReadKeyStroke (\r
3233 Private->TextInList[Index],\r
3234 &CurrentKey\r
3235 );\r
3236 if (!EFI_ERROR (Status)) {\r
3237 *Key = CurrentKey;\r
3238 return Status;\r
3239 }\r
3240 }\r
3241\r
3242 return EFI_NOT_READY;\r
3243}\r
3244\r
3245\r
3246/**\r
3247 Reads the next keystroke from the input device. The WaitForKey Event can\r
3248 be used to test for existance of a keystroke via WaitForEvent () call.\r
3249\r
3250 @param This Protocol instance pointer.\r
3251 @param Key Driver may perform diagnostics on reset.\r
3252\r
3253 @retval EFI_SUCCESS The keystroke information was returned.\r
3254 @retval EFI_NOT_READY There was no keystroke data availiable.\r
3255 @retval EFI_DEVICE_ERROR The keydtroke information was not returned due\r
3256 to hardware errors.\r
3257\r
3258**/\r
3259EFI_STATUS\r
3260EFIAPI\r
3261ConSplitterTextInReadKeyStroke (\r
3262 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,\r
3263 OUT EFI_INPUT_KEY *Key\r
3264 )\r
3265{\r
3266 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3267\r
3268 Private = TEXT_IN_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
3269\r
3270 Private->KeyEventSignalState = FALSE;\r
3271\r
3272 return ConSplitterTextInPrivateReadKeyStroke (Private, Key);\r
3273}\r
3274\r
3275\r
3276/**\r
3277 This event aggregates all the events of the ConIn devices in the spliter.\r
3278\r
3279 If any events of physical ConIn devices are signaled, signal the ConIn\r
3280 spliter event. This will cause the calling code to call\r
3281 ConSplitterTextInReadKeyStroke ().\r
3282\r
3283 @param Event The Event assoicated with callback.\r
3284 @param Context Context registered when Event was created.\r
3285\r
3286**/\r
3287VOID\r
3288EFIAPI\r
3289ConSplitterTextInWaitForKey (\r
3290 IN EFI_EVENT Event,\r
3291 IN VOID *Context\r
3292 )\r
3293{\r
3294 EFI_STATUS Status;\r
3295 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3296 UINTN Index;\r
3297\r
3298 Private = (TEXT_IN_SPLITTER_PRIVATE_DATA *) Context;\r
3299\r
3300 if (Private->KeyEventSignalState) {\r
3301 //\r
3302 // If KeyEventSignalState is flagged before, and not cleared by Reset() or ReadKeyStroke()\r
3303 //\r
3304 gBS->SignalEvent (Event);\r
3305 return ;\r
3306 }\r
3307\r
3308 //\r
3309 // If any physical console input device has key input, signal the event.\r
3310 //\r
3311 for (Index = 0; Index < Private->CurrentNumberOfConsoles; Index++) {\r
3312 Status = gBS->CheckEvent (Private->TextInList[Index]->WaitForKey);\r
3313 if (!EFI_ERROR (Status)) {\r
3314 gBS->SignalEvent (Event);\r
3315 Private->KeyEventSignalState = TRUE;\r
3316 }\r
3317 }\r
3318}\r
3319\r
3320\r
3321\r
3322/**\r
3323 Test if the key has been registered on input device.\r
3324\r
3325 @param RegsiteredData A pointer to a buffer that is filled in with the\r
3326 keystroke state data for the key that was\r
3327 registered.\r
3328 @param InputData A pointer to a buffer that is filled in with the\r
3329 keystroke state data for the key that was\r
3330 pressed.\r
3331\r
3332 @retval TRUE Key be pressed matches a registered key.\r
3333 @retval FLASE Match failed.\r
3334\r
3335**/\r
3336BOOLEAN\r
3337IsKeyRegistered (\r
3338 IN EFI_KEY_DATA *RegsiteredData,\r
3339 IN EFI_KEY_DATA *InputData\r
3340 )\r
3341{\r
3342 ASSERT (RegsiteredData != NULL && InputData != NULL);\r
3343\r
3344 if ((RegsiteredData->Key.ScanCode != InputData->Key.ScanCode) ||\r
3345 (RegsiteredData->Key.UnicodeChar != InputData->Key.UnicodeChar)) {\r
3346 return FALSE;\r
3347 }\r
3348\r
3349 //\r
3350 // Assume KeyShiftState/KeyToggleState = 0 in Registered key data means these state could be ignored.\r
3351 //\r
3352 if (RegsiteredData->KeyState.KeyShiftState != 0 &&\r
3353 RegsiteredData->KeyState.KeyShiftState != InputData->KeyState.KeyShiftState) {\r
3354 return FALSE;\r
3355 }\r
3356 if (RegsiteredData->KeyState.KeyToggleState != 0 &&\r
3357 RegsiteredData->KeyState.KeyToggleState != InputData->KeyState.KeyToggleState) {\r
3358 return FALSE;\r
3359 }\r
3360\r
3361 return TRUE;\r
3362\r
3363}\r
3364\r
3365\r
3366/**\r
3367 Reset the input device and optionaly run diagnostics\r
3368\r
3369 @param This Protocol instance pointer.\r
3370 @param ExtendedVerification Driver may perform diagnostics on reset.\r
3371\r
3372 @retval EFI_SUCCESS The device was reset.\r
3373 @retval EFI_DEVICE_ERROR The device is not functioning properly and could\r
3374 not be reset.\r
3375\r
3376**/\r
3377EFI_STATUS\r
3378EFIAPI\r
3379ConSplitterTextInResetEx (\r
3380 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,\r
3381 IN BOOLEAN ExtendedVerification\r
3382 )\r
3383{\r
3384 EFI_STATUS Status;\r
3385 EFI_STATUS ReturnStatus;\r
3386 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3387 UINTN Index;\r
3388\r
3389 Private = TEXT_IN_EX_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
3390\r
3391 Private->KeyEventSignalState = FALSE;\r
3392\r
3393 //\r
3394 // return the worst status met\r
3395 //\r
3396 for (Index = 0, ReturnStatus = EFI_SUCCESS; Index < Private->CurrentNumberOfExConsoles; Index++) {\r
3397 Status = Private->TextInExList[Index]->Reset (\r
3398 Private->TextInExList[Index],\r
3399 ExtendedVerification\r
3400 );\r
3401 if (EFI_ERROR (Status)) {\r
3402 ReturnStatus = Status;\r
3403 }\r
3404 }\r
3405\r
3406 return ReturnStatus;\r
3407\r
3408}\r
3409\r
3410\r
3411/**\r
3412 Reads the next keystroke from the input device. The WaitForKey Event can\r
3413 be used to test for existance of a keystroke via WaitForEvent () call.\r
3414\r
3415 @param This Protocol instance pointer.\r
3416 @param KeyData A pointer to a buffer that is filled in with the\r
3417 keystroke state data for the key that was\r
3418 pressed.\r
3419\r
3420 @retval EFI_SUCCESS The keystroke information was returned.\r
3421 @retval EFI_NOT_READY There was no keystroke data availiable.\r
3422 @retval EFI_DEVICE_ERROR The keystroke information was not returned due\r
3423 to hardware errors.\r
3424 @retval EFI_INVALID_PARAMETER KeyData is NULL.\r
3425\r
3426**/\r
3427EFI_STATUS\r
3428EFIAPI\r
3429ConSplitterTextInReadKeyStrokeEx (\r
3430 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,\r
3431 OUT EFI_KEY_DATA *KeyData\r
3432 )\r
3433{\r
3434 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3435 EFI_STATUS Status;\r
3436 UINTN Index;\r
3437 EFI_KEY_DATA CurrentKeyData;\r
3438\r
3439\r
3440 if (KeyData == NULL) {\r
3441 return EFI_INVALID_PARAMETER;\r
3442 }\r
3443\r
3444 Private = TEXT_IN_EX_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
3445\r
3446 Private->KeyEventSignalState = FALSE;\r
3447\r
3448 KeyData->Key.UnicodeChar = 0;\r
3449 KeyData->Key.ScanCode = SCAN_NULL;\r
3450\r
3451 //\r
3452 // if no physical console input device exists, return EFI_NOT_READY;\r
3453 // if any physical console input device has key input,\r
3454 // return the key and EFI_SUCCESS.\r
3455 //\r
3456 for (Index = 0; Index < Private->CurrentNumberOfExConsoles; Index++) {\r
3457 Status = Private->TextInExList[Index]->ReadKeyStrokeEx (\r
3458 Private->TextInExList[Index],\r
3459 &CurrentKeyData\r
3460 );\r
3461 if (!EFI_ERROR (Status)) {\r
3462 CopyMem (KeyData, &CurrentKeyData, sizeof (CurrentKeyData));\r
3463 return Status;\r
3464 }\r
3465 }\r
3466\r
3467 return EFI_NOT_READY;\r
3468}\r
3469\r
3470\r
3471/**\r
3472 Set certain state for the input device.\r
3473\r
3474 @param This Protocol instance pointer.\r
3475 @param KeyToggleState A pointer to the EFI_KEY_TOGGLE_STATE to set the\r
3476 state for the input device.\r
3477\r
3478 @retval EFI_SUCCESS The device state was set successfully.\r
3479 @retval EFI_DEVICE_ERROR The device is not functioning correctly and\r
3480 could not have the setting adjusted.\r
3481 @retval EFI_UNSUPPORTED The device does not have the ability to set its\r
3482 state.\r
3483 @retval EFI_INVALID_PARAMETER KeyToggleState is NULL.\r
3484\r
3485**/\r
3486EFI_STATUS\r
3487EFIAPI\r
3488ConSplitterTextInSetState (\r
3489 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,\r
3490 IN EFI_KEY_TOGGLE_STATE *KeyToggleState\r
3491 )\r
3492{\r
3493 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3494 EFI_STATUS Status;\r
3495 UINTN Index;\r
3496\r
3497 if (KeyToggleState == NULL) {\r
3498 return EFI_INVALID_PARAMETER;\r
3499 }\r
3500\r
3501 Private = TEXT_IN_EX_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
3502\r
3503 //\r
3504 // if no physical console input device exists, return EFI_SUCCESS;\r
3505 // otherwise return the status of setting state of physical console input device\r
3506 //\r
3507 for (Index = 0; Index < Private->CurrentNumberOfExConsoles; Index++) {\r
3508 Status = Private->TextInExList[Index]->SetState (\r
3509 Private->TextInExList[Index],\r
3510 KeyToggleState\r
3511 );\r
3512 if (EFI_ERROR (Status)) {\r
3513 return Status;\r
3514 }\r
3515 }\r
3516\r
3517 return EFI_SUCCESS;\r
3518\r
3519}\r
3520\r
3521\r
3522/**\r
3523 Register a notification function for a particular keystroke for the input device.\r
3524\r
3525 @param This Protocol instance pointer.\r
3526 @param KeyData A pointer to a buffer that is filled in with the\r
3527 keystroke information data for the key that was\r
3528 pressed.\r
3529 @param KeyNotificationFunction Points to the function to be called when the key\r
3530 sequence is typed specified by KeyData.\r
3531 @param NotifyHandle Points to the unique handle assigned to the\r
3532 registered notification.\r
3533\r
3534 @retval EFI_SUCCESS The notification function was registered\r
3535 successfully.\r
3536 @retval EFI_OUT_OF_RESOURCES Unable to allocate resources for necesssary data\r
3537 structures.\r
3538 @retval EFI_INVALID_PARAMETER KeyData or KeyNotificationFunction or NotifyHandle is NULL.\r
3539\r
3540**/\r
3541EFI_STATUS\r
3542EFIAPI\r
3543ConSplitterTextInRegisterKeyNotify (\r
3544 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,\r
3545 IN EFI_KEY_DATA *KeyData,\r
3546 IN EFI_KEY_NOTIFY_FUNCTION KeyNotificationFunction,\r
3547 OUT EFI_HANDLE *NotifyHandle\r
3548 )\r
3549{\r
3550 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3551 EFI_STATUS Status;\r
3552 UINTN Index;\r
3553 TEXT_IN_EX_SPLITTER_NOTIFY *NewNotify;\r
3554 LIST_ENTRY *Link;\r
3555 TEXT_IN_EX_SPLITTER_NOTIFY *CurrentNotify;\r
3556\r
3557\r
3558 if (KeyData == NULL || NotifyHandle == NULL || KeyNotificationFunction == NULL) {\r
3559 return EFI_INVALID_PARAMETER;\r
3560 }\r
3561\r
3562 Private = TEXT_IN_EX_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
3563\r
3564 //\r
3565 // If no physical console input device exists,\r
3566 // return EFI_SUCCESS directly.\r
3567 //\r
3568 if (Private->CurrentNumberOfExConsoles <= 0) {\r
3569 return EFI_SUCCESS;\r
3570 }\r
3571\r
3572 //\r
3573 // Return EFI_SUCCESS if the (KeyData, NotificationFunction) is already registered.\r
3574 //\r
3575 for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) {\r
3576 CurrentNotify = TEXT_IN_EX_SPLITTER_NOTIFY_FROM_THIS (Link);\r
3577 if (IsKeyRegistered (&CurrentNotify->KeyData, KeyData)) {\r
3578 if (CurrentNotify->KeyNotificationFn == KeyNotificationFunction) {\r
3579 *NotifyHandle = CurrentNotify->NotifyHandle;\r
3580 return EFI_SUCCESS;\r
3581 }\r
3582 }\r
3583 }\r
3584\r
3585 //\r
3586 // Allocate resource to save the notification function\r
3587 //\r
3588 NewNotify = (TEXT_IN_EX_SPLITTER_NOTIFY *) AllocateZeroPool (sizeof (TEXT_IN_EX_SPLITTER_NOTIFY));\r
3589 if (NewNotify == NULL) {\r
3590 return EFI_OUT_OF_RESOURCES;\r
3591 }\r
3592 NewNotify->NotifyHandleList = (EFI_HANDLE *) AllocateZeroPool (sizeof (EFI_HANDLE) * Private->CurrentNumberOfExConsoles);\r
3593 if (NewNotify->NotifyHandleList == NULL) {\r
3594 gBS->FreePool (NewNotify);\r
3595 return EFI_OUT_OF_RESOURCES;\r
3596 }\r
3597 NewNotify->Signature = TEXT_IN_EX_SPLITTER_NOTIFY_SIGNATURE;\r
3598 NewNotify->KeyNotificationFn = KeyNotificationFunction;\r
3599 NewNotify->NotifyHandle = (EFI_HANDLE) NewNotify;\r
3600 CopyMem (&NewNotify->KeyData, KeyData, sizeof (KeyData));\r
3601\r
3602 //\r
3603 // Return the wrong status of registering key notify of\r
3604 // physical console input device if meet problems\r
3605 //\r
3606 for (Index = 0; Index < Private->CurrentNumberOfExConsoles; Index++) {\r
3607 Status = Private->TextInExList[Index]->RegisterKeyNotify (\r
3608 Private->TextInExList[Index],\r
3609 KeyData,\r
3610 KeyNotificationFunction,\r
3611 &NewNotify->NotifyHandleList[Index]\r
3612 );\r
3613 if (EFI_ERROR (Status)) {\r
3614 gBS->FreePool (NewNotify->NotifyHandleList);\r
3615 gBS->FreePool (NewNotify);\r
3616 return Status;\r
3617 }\r
3618 }\r
3619\r
3620 InsertTailList (&mConIn.NotifyList, &NewNotify->NotifyEntry);\r
3621\r
3622 *NotifyHandle = NewNotify->NotifyHandle;\r
3623\r
3624 return EFI_SUCCESS;\r
3625\r
3626}\r
3627\r
3628\r
3629/**\r
3630 Remove a registered notification function from a particular keystroke.\r
3631\r
3632 @param This Protocol instance pointer.\r
3633 @param NotificationHandle The handle of the notification function being\r
3634 unregistered.\r
3635\r
3636 @retval EFI_SUCCESS The notification function was unregistered\r
3637 successfully.\r
3638 @retval EFI_INVALID_PARAMETER The NotificationHandle is invalid.\r
3639 @retval EFI_NOT_FOUND Can not find the matching entry in database.\r
3640\r
3641**/\r
3642EFI_STATUS\r
3643EFIAPI\r
3644ConSplitterTextInUnregisterKeyNotify (\r
3645 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,\r
3646 IN EFI_HANDLE NotificationHandle\r
3647 )\r
3648{\r
3649 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3650 EFI_STATUS Status;\r
3651 UINTN Index;\r
3652 TEXT_IN_EX_SPLITTER_NOTIFY *CurrentNotify;\r
3653 LIST_ENTRY *Link;\r
3654\r
3655 if (NotificationHandle == NULL) {\r
3656 return EFI_INVALID_PARAMETER;\r
3657 }\r
3658\r
3659 if (((TEXT_IN_EX_SPLITTER_NOTIFY *) NotificationHandle)->Signature != TEXT_IN_EX_SPLITTER_NOTIFY_SIGNATURE) {\r
3660 return EFI_INVALID_PARAMETER;\r
3661 } \r
3662 \r
3663 Private = TEXT_IN_EX_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
3664\r
3665 //\r
3666 // if no physical console input device exists,\r
3667 // return EFI_SUCCESS directly.\r
3668 //\r
3669 if (Private->CurrentNumberOfExConsoles <= 0) {\r
3670 return EFI_SUCCESS;\r
3671 }\r
3672\r
3673 for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) {\r
3674 CurrentNotify = TEXT_IN_EX_SPLITTER_NOTIFY_FROM_THIS (Link);\r
3675 if (CurrentNotify->NotifyHandle == NotificationHandle) {\r
3676 for (Index = 0; Index < Private->CurrentNumberOfExConsoles; Index++) {\r
3677 Status = Private->TextInExList[Index]->UnregisterKeyNotify (\r
3678 Private->TextInExList[Index],\r
3679 CurrentNotify->NotifyHandleList[Index]\r
3680 );\r
3681 if (EFI_ERROR (Status)) {\r
3682 return Status;\r
3683 }\r
3684 }\r
3685 RemoveEntryList (&CurrentNotify->NotifyEntry);\r
3686\r
3687 gBS->FreePool (CurrentNotify->NotifyHandleList);\r
3688 gBS->FreePool (CurrentNotify);\r
3689 return EFI_SUCCESS;\r
3690 }\r
3691 }\r
3692\r
3693 return EFI_NOT_FOUND;\r
3694\r
3695}\r
3696\r
3697\r
3698/**\r
3699 Reset the input device and optionaly run diagnostics\r
3700\r
3701 @param This Protocol instance pointer.\r
3702 @param ExtendedVerification Driver may perform diagnostics on reset.\r
3703\r
3704 @retval EFI_SUCCESS The device was reset.\r
3705 @retval EFI_DEVICE_ERROR The device is not functioning properly and could\r
3706 not be reset.\r
3707\r
3708**/\r
3709EFI_STATUS\r
3710EFIAPI\r
3711ConSplitterSimplePointerReset (\r
3712 IN EFI_SIMPLE_POINTER_PROTOCOL *This,\r
3713 IN BOOLEAN ExtendedVerification\r
3714 )\r
3715{\r
3716 EFI_STATUS Status;\r
3717 EFI_STATUS ReturnStatus;\r
3718 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3719 UINTN Index;\r
3720\r
3721 Private = TEXT_IN_SPLITTER_PRIVATE_DATA_FROM_SIMPLE_POINTER_THIS (This);\r
3722\r
3723 Private->InputEventSignalState = FALSE;\r
3724\r
3725 if (Private->CurrentNumberOfPointers == 0) {\r
3726 return EFI_SUCCESS;\r
3727 }\r
3728 //\r
3729 // return the worst status met\r
3730 //\r
3731 for (Index = 0, ReturnStatus = EFI_SUCCESS; Index < Private->CurrentNumberOfPointers; Index++) {\r
3732 Status = Private->PointerList[Index]->Reset (\r
3733 Private->PointerList[Index],\r
3734 ExtendedVerification\r
3735 );\r
3736 if (EFI_ERROR (Status)) {\r
3737 ReturnStatus = Status;\r
3738 }\r
3739 }\r
3740\r
3741 return ReturnStatus;\r
3742}\r
3743\r
3744\r
3745/**\r
3746 Reads the next keystroke from the input device. The WaitForKey Event can\r
3747 be used to test for existance of a keystroke via WaitForEvent () call.\r
3748\r
3749 @param Private Protocol instance pointer.\r
3750 @param State The state information of simple pointer device.\r
3751\r
3752 @retval EFI_SUCCESS The keystroke information was returned.\r
3753 @retval EFI_NOT_READY There was no keystroke data availiable.\r
3754 @retval EFI_DEVICE_ERROR The keydtroke information was not returned due\r
3755 to hardware errors.\r
3756\r
3757**/\r
3758EFI_STATUS\r
3759EFIAPI\r
3760ConSplitterSimplePointerPrivateGetState (\r
3761 IN TEXT_IN_SPLITTER_PRIVATE_DATA *Private,\r
3762 IN OUT EFI_SIMPLE_POINTER_STATE *State\r
3763 )\r
3764{\r
3765 EFI_STATUS Status;\r
3766 EFI_STATUS ReturnStatus;\r
3767 UINTN Index;\r
3768 EFI_SIMPLE_POINTER_STATE CurrentState;\r
3769\r
3770 State->RelativeMovementX = 0;\r
3771 State->RelativeMovementY = 0;\r
3772 State->RelativeMovementZ = 0;\r
3773 State->LeftButton = FALSE;\r
3774 State->RightButton = FALSE;\r
3775\r
3776 //\r
3777 // if no physical console input device exists, return EFI_NOT_READY;\r
3778 // if any physical console input device has key input,\r
3779 // return the key and EFI_SUCCESS.\r
3780 //\r
3781 ReturnStatus = EFI_NOT_READY;\r
3782 for (Index = 0; Index < Private->CurrentNumberOfPointers; Index++) {\r
3783\r
3784 Status = Private->PointerList[Index]->GetState (\r
3785 Private->PointerList[Index],\r
3786 &CurrentState\r
3787 );\r
3788 if (!EFI_ERROR (Status)) {\r
3789 if (ReturnStatus == EFI_NOT_READY) {\r
3790 ReturnStatus = EFI_SUCCESS;\r
3791 }\r
3792\r
3793 if (CurrentState.LeftButton) {\r
3794 State->LeftButton = TRUE;\r
3795 }\r
3796\r
3797 if (CurrentState.RightButton) {\r
3798 State->RightButton = TRUE;\r
3799 }\r
3800\r
3801 if (CurrentState.RelativeMovementX != 0 && Private->PointerList[Index]->Mode->ResolutionX != 0) {\r
3802 State->RelativeMovementX += (CurrentState.RelativeMovementX * (INT32) Private->SimplePointerMode.ResolutionX) / (INT32) Private->PointerList[Index]->Mode->ResolutionX;\r
3803 }\r
3804\r
3805 if (CurrentState.RelativeMovementY != 0 && Private->PointerList[Index]->Mode->ResolutionY != 0) {\r
3806 State->RelativeMovementY += (CurrentState.RelativeMovementY * (INT32) Private->SimplePointerMode.ResolutionY) / (INT32) Private->PointerList[Index]->Mode->ResolutionY;\r
3807 }\r
3808\r
3809 if (CurrentState.RelativeMovementZ != 0 && Private->PointerList[Index]->Mode->ResolutionZ != 0) {\r
3810 State->RelativeMovementZ += (CurrentState.RelativeMovementZ * (INT32) Private->SimplePointerMode.ResolutionZ) / (INT32) Private->PointerList[Index]->Mode->ResolutionZ;\r
3811 }\r
3812 } else if (Status == EFI_DEVICE_ERROR) {\r
3813 ReturnStatus = EFI_DEVICE_ERROR;\r
3814 }\r
3815 }\r
3816\r
3817 return ReturnStatus;\r
3818}\r
3819\r
3820\r
3821/**\r
3822 Reads the next keystroke from the input device. The WaitForKey Event can\r
3823 be used to test for existance of a keystroke via WaitForEvent () call.\r
3824\r
3825 @param This A pointer to protocol instance.\r
3826 @param State A pointer to state information on the pointer device\r
3827\r
3828 @retval EFI_SUCCESS The keystroke information was returned in State.\r
3829 @retval EFI_NOT_READY There was no keystroke data availiable.\r
3830 @retval EFI_DEVICE_ERROR The keydtroke information was not returned due\r
3831 to hardware errors.\r
3832\r
3833**/\r
3834EFI_STATUS\r
3835EFIAPI\r
3836ConSplitterSimplePointerGetState (\r
3837 IN EFI_SIMPLE_POINTER_PROTOCOL *This,\r
3838 IN OUT EFI_SIMPLE_POINTER_STATE *State\r
3839 )\r
3840{\r
3841 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3842\r
3843 Private = TEXT_IN_SPLITTER_PRIVATE_DATA_FROM_SIMPLE_POINTER_THIS (This);\r
3844\r
3845 Private->InputEventSignalState = FALSE;\r
3846\r
3847 return ConSplitterSimplePointerPrivateGetState (Private, State);\r
3848}\r
3849\r
3850\r
3851/**\r
3852 This event agregates all the events of the ConIn devices in the spliter.\r
3853 If any events of physical ConIn devices are signaled, signal the ConIn\r
3854 spliter event. This will cause the calling code to call\r
3855 ConSplitterTextInReadKeyStroke ().\r
3856\r
3857 @param Event The Event assoicated with callback.\r
3858 @param Context Context registered when Event was created.\r
3859\r
3860**/\r
3861VOID\r
3862EFIAPI\r
3863ConSplitterSimplePointerWaitForInput (\r
3864 IN EFI_EVENT Event,\r
3865 IN VOID *Context\r
3866 )\r
3867{\r
3868 EFI_STATUS Status;\r
3869 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3870 UINTN Index;\r
3871\r
3872 Private = (TEXT_IN_SPLITTER_PRIVATE_DATA *) Context;\r
3873\r
3874 //\r
3875 // if InputEventSignalState is flagged before, and not cleared by Reset() or ReadKeyStroke()\r
3876 //\r
3877 if (Private->InputEventSignalState) {\r
3878 gBS->SignalEvent (Event);\r
3879 return ;\r
3880 }\r
3881 //\r
3882 // if any physical console input device has key input, signal the event.\r
3883 //\r
3884 for (Index = 0; Index < Private->CurrentNumberOfPointers; Index++) {\r
3885 Status = gBS->CheckEvent (Private->PointerList[Index]->WaitForInput);\r
3886 if (!EFI_ERROR (Status)) {\r
3887 gBS->SignalEvent (Event);\r
3888 Private->InputEventSignalState = TRUE;\r
3889 }\r
3890 }\r
3891}\r
3892\r
3893/**\r
3894 Resets the pointer device hardware.\r
3895\r
3896 @param This Protocol instance pointer.\r
3897 @param ExtendedVerification Driver may perform diagnostics on reset.\r
3898\r
3899 @retval EFI_SUCCESS The device was reset.\r
3900 @retval EFI_DEVICE_ERROR The device is not functioning correctly and\r
3901 could not be reset.\r
3902\r
3903**/\r
3904EFI_STATUS\r
3905EFIAPI\r
3906ConSplitterAbsolutePointerReset (\r
3907 IN EFI_ABSOLUTE_POINTER_PROTOCOL *This,\r
3908 IN BOOLEAN ExtendedVerification\r
3909 )\r
3910{\r
3911 EFI_STATUS Status;\r
3912 EFI_STATUS ReturnStatus;\r
3913 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3914 UINTN Index;\r
3915\r
3916 Private = TEXT_IN_SPLITTER_PRIVATE_DATA_FROM_ABSOLUTE_POINTER_THIS (This);\r
3917\r
3918 Private->AbsoluteInputEventSignalState = FALSE;\r
3919\r
3920 if (Private->CurrentNumberOfAbsolutePointers == 0) {\r
3921 return EFI_SUCCESS;\r
3922 }\r
3923 //\r
3924 // return the worst status met\r
3925 //\r
3926 for (Index = 0, ReturnStatus = EFI_SUCCESS; Index < Private->CurrentNumberOfAbsolutePointers; Index++) {\r
3927 Status = Private->AbsolutePointerList[Index]->Reset (\r
3928 Private->AbsolutePointerList[Index],\r
3929 ExtendedVerification\r
3930 );\r
3931 if (EFI_ERROR (Status)) {\r
3932 ReturnStatus = Status;\r
3933 }\r
3934 }\r
3935\r
3936 return ReturnStatus;\r
3937}\r
3938\r
3939\r
3940/**\r
3941 Retrieves the current state of a pointer device.\r
3942\r
3943 @param This Protocol instance pointer.\r
3944 @param State A pointer to the state information on the\r
3945 pointer device.\r
3946\r
3947 @retval EFI_SUCCESS The state of the pointer device was returned in\r
3948 State..\r
3949 @retval EFI_NOT_READY The state of the pointer device has not changed\r
3950 since the last call to GetState().\r
3951 @retval EFI_DEVICE_ERROR A device error occurred while attempting to\r
3952 retrieve the pointer device's current state.\r
3953\r
3954**/\r
3955EFI_STATUS\r
3956EFIAPI\r
3957ConSplitterAbsolutePointerGetState (\r
3958 IN EFI_ABSOLUTE_POINTER_PROTOCOL *This,\r
3959 IN OUT EFI_ABSOLUTE_POINTER_STATE *State\r
3960 )\r
3961{\r
3962 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
3963 EFI_STATUS Status;\r
3964 EFI_STATUS ReturnStatus;\r
3965 UINTN Index;\r
3966 EFI_ABSOLUTE_POINTER_STATE CurrentState;\r
3967\r
3968\r
3969 Private = TEXT_IN_SPLITTER_PRIVATE_DATA_FROM_ABSOLUTE_POINTER_THIS (This);\r
3970\r
3971 Private->AbsoluteInputEventSignalState = FALSE;\r
3972\r
3973 State->CurrentX = 0;\r
3974 State->CurrentY = 0;\r
3975 State->CurrentZ = 0;\r
3976 State->ActiveButtons = 0;\r
3977\r
3978 //\r
3979 // if no physical pointer device exists, return EFI_NOT_READY;\r
3980 // if any physical pointer device has changed state,\r
3981 // return the state and EFI_SUCCESS.\r
3982 //\r
3983 ReturnStatus = EFI_NOT_READY;\r
3984 for (Index = 0; Index < Private->CurrentNumberOfAbsolutePointers; Index++) {\r
3985\r
3986 Status = Private->AbsolutePointerList[Index]->GetState (\r
3987 Private->AbsolutePointerList[Index],\r
3988 &CurrentState\r
3989 );\r
3990 if (!EFI_ERROR (Status)) {\r
3991 if (ReturnStatus == EFI_NOT_READY) {\r
3992 ReturnStatus = EFI_SUCCESS;\r
3993 }\r
3994\r
3995 State->ActiveButtons = CurrentState.ActiveButtons;\r
3996\r
3997 if (!(Private->AbsolutePointerMode.AbsoluteMinX == 0 && Private->AbsolutePointerMode.AbsoluteMaxX == 0)) {\r
3998 State->CurrentX = CurrentState.CurrentX;\r
3999 }\r
4000 if (!(Private->AbsolutePointerMode.AbsoluteMinY == 0 && Private->AbsolutePointerMode.AbsoluteMaxY == 0)) {\r
4001 State->CurrentY = CurrentState.CurrentY;\r
4002 }\r
4003 if (!(Private->AbsolutePointerMode.AbsoluteMinZ == 0 && Private->AbsolutePointerMode.AbsoluteMaxZ == 0)) {\r
4004 State->CurrentZ = CurrentState.CurrentZ;\r
4005 }\r
4006\r
4007 } else if (Status == EFI_DEVICE_ERROR) {\r
4008 ReturnStatus = EFI_DEVICE_ERROR;\r
4009 }\r
4010 }\r
4011\r
4012 return ReturnStatus;\r
4013}\r
4014\r
4015\r
4016/**\r
4017 This event agregates all the events of the pointer devices in the splitter.\r
4018 If any events of physical pointer devices are signaled, signal the pointer\r
4019 splitter event. This will cause the calling code to call\r
4020 ConSplitterAbsolutePointerGetState ().\r
4021\r
4022 @param Event The Event assoicated with callback.\r
4023 @param Context Context registered when Event was created.\r
4024\r
4025**/\r
4026VOID\r
4027EFIAPI\r
4028ConSplitterAbsolutePointerWaitForInput (\r
4029 IN EFI_EVENT Event,\r
4030 IN VOID *Context\r
4031 )\r
4032{\r
4033 EFI_STATUS Status;\r
4034 TEXT_IN_SPLITTER_PRIVATE_DATA *Private;\r
4035 UINTN Index;\r
4036\r
4037 Private = (TEXT_IN_SPLITTER_PRIVATE_DATA *) Context;\r
4038\r
4039 //\r
4040 // if AbsoluteInputEventSignalState is flagged before,\r
4041 // and not cleared by Reset() or GetState(), signal it\r
4042 //\r
4043 if (Private->AbsoluteInputEventSignalState) {\r
4044 gBS->SignalEvent (Event);\r
4045 return ;\r
4046 }\r
4047 //\r
4048 // if any physical console input device has key input, signal the event.\r
4049 //\r
4050 for (Index = 0; Index < Private->CurrentNumberOfAbsolutePointers; Index++) {\r
4051 Status = gBS->CheckEvent (Private->AbsolutePointerList[Index]->WaitForInput);\r
4052 if (!EFI_ERROR (Status)) {\r
4053 gBS->SignalEvent (Event);\r
4054 Private->AbsoluteInputEventSignalState = TRUE;\r
4055 }\r
4056 }\r
4057}\r
4058\r
4059\r
4060/**\r
4061 Reset the text output device hardware and optionaly run diagnostics\r
4062\r
4063 @param This Protocol instance pointer.\r
4064 @param ExtendedVerification Driver may perform more exhaustive verfication\r
4065 operation of the device during reset.\r
4066\r
4067 @retval EFI_SUCCESS The text output device was reset.\r
4068 @retval EFI_DEVICE_ERROR The text output device is not functioning\r
4069 correctly and could not be reset.\r
4070\r
4071**/\r
4072EFI_STATUS\r
4073EFIAPI\r
4074ConSplitterTextOutReset (\r
4075 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,\r
4076 IN BOOLEAN ExtendedVerification\r
4077 )\r
4078{\r
4079 EFI_STATUS Status;\r
4080 TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;\r
4081 UINTN Index;\r
4082 EFI_STATUS ReturnStatus;\r
4083\r
4084 Private = TEXT_OUT_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
4085\r
4086 //\r
4087 // return the worst status met\r
4088 //\r
4089 for (Index = 0, ReturnStatus = EFI_SUCCESS; Index < Private->CurrentNumberOfConsoles; Index++) {\r
4090 Status = Private->TextOutList[Index].TextOut->Reset (\r
4091 Private->TextOutList[Index].TextOut,\r
4092 ExtendedVerification\r
4093 );\r
4094 if (EFI_ERROR (Status)) {\r
4095 ReturnStatus = Status;\r
4096 }\r
4097 }\r
4098\r
4099 This->SetAttribute (This, EFI_TEXT_ATTR (This->Mode->Attribute & 0x0F, EFI_BLACK));\r
4100\r
4101 //\r
4102 // reset all mode parameters\r
4103 //\r
4104 TextOutSetMode (Private, 0);\r
4105\r
4106 return ReturnStatus;\r
4107}\r
4108\r
4109\r
4110/**\r
4111 Write a Unicode string to the output device.\r
4112\r
4113 @param This Protocol instance pointer.\r
4114 @param WString The NULL-terminated Unicode string to be\r
4115 displayed on the output device(s). All output\r
4116 devices must also support the Unicode drawing\r
4117 defined in this file.\r
4118\r
4119 @retval EFI_SUCCESS The string was output to the device.\r
4120 @retval EFI_DEVICE_ERROR The device reported an error while attempting to\r
4121 output the text.\r
4122 @retval EFI_UNSUPPORTED The output device's mode is not currently in a\r
4123 defined text mode.\r
4124 @retval EFI_WARN_UNKNOWN_GLYPH This warning code indicates that some of the\r
4125 characters in the Unicode string could not be\r
4126 rendered and were skipped.\r
4127\r
4128**/\r
4129EFI_STATUS\r
4130EFIAPI\r
4131ConSplitterTextOutOutputString (\r
4132 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,\r
4133 IN CHAR16 *WString\r
4134 )\r
4135{\r
4136 EFI_STATUS Status;\r
4137 TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;\r
4138 UINTN Index;\r
4139 UINTN BackSpaceCount;\r
4140 EFI_STATUS ReturnStatus;\r
4141 CHAR16 *TargetString;\r
4142\r
4143 This->SetAttribute (This, This->Mode->Attribute);\r
4144\r
4145 Private = TEXT_OUT_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
4146\r
4147 BackSpaceCount = 0;\r
4148 for (TargetString = WString; *TargetString != L'\0'; TargetString++) {\r
4149 if (*TargetString == CHAR_BACKSPACE) {\r
4150 BackSpaceCount++;\r
4151 }\r
4152\r
4153 }\r
4154\r
4155 if (BackSpaceCount == 0) {\r
4156 TargetString = WString;\r
4157 } else {\r
4158 TargetString = AllocatePool (sizeof (CHAR16) * (StrLen (WString) + BackSpaceCount + 1));\r
4159 ASSERT (TargetString != NULL);\r
4160\r
4161 StrCpy (TargetString, WString);\r
4162 }\r
4163 //\r
4164 // return the worst status met\r
4165 //\r
4166 for (Index = 0, ReturnStatus = EFI_SUCCESS; Index < Private->CurrentNumberOfConsoles; Index++) {\r
4167 Status = Private->TextOutList[Index].TextOut->OutputString (\r
4168 Private->TextOutList[Index].TextOut,\r
4169 TargetString\r
4170 );\r
4171 if (EFI_ERROR (Status)) {\r
4172 ReturnStatus = Status;\r
4173 }\r
4174 }\r
4175\r
4176 Private->TextOutMode.CursorColumn = Private->TextOutList[0].TextOut->Mode->CursorColumn;\r
4177 Private->TextOutMode.CursorRow = Private->TextOutList[0].TextOut->Mode->CursorRow;\r
4178\r
4179 if (BackSpaceCount > 0) {\r
4180 FreePool (TargetString);\r
4181 }\r
4182\r
4183 return ReturnStatus;\r
4184}\r
4185\r
4186\r
4187/**\r
4188 Verifies that all characters in a Unicode string can be output to the\r
4189 target device.\r
4190\r
4191 @param This Protocol instance pointer.\r
4192 @param WString The NULL-terminated Unicode string to be\r
4193 examined for the output device(s).\r
4194\r
4195 @retval EFI_SUCCESS The device(s) are capable of rendering the\r
4196 output string.\r
4197 @retval EFI_UNSUPPORTED Some of the characters in the Unicode string\r
4198 cannot be rendered by one or more of the output\r
4199 devices mapped by the EFI handle.\r
4200\r
4201**/\r
4202EFI_STATUS\r
4203EFIAPI\r
4204ConSplitterTextOutTestString (\r
4205 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,\r
4206 IN CHAR16 *WString\r
4207 )\r
4208{\r
4209 EFI_STATUS Status;\r
4210 TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;\r
4211 UINTN Index;\r
4212 EFI_STATUS ReturnStatus;\r
4213\r
4214 Private = TEXT_OUT_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
4215\r
4216 //\r
4217 // return the worst status met\r
4218 //\r
4219 for (Index = 0, ReturnStatus = EFI_SUCCESS; Index < Private->CurrentNumberOfConsoles; Index++) {\r
4220 Status = Private->TextOutList[Index].TextOut->TestString (\r
4221 Private->TextOutList[Index].TextOut,\r
4222 WString\r
4223 );\r
4224 if (EFI_ERROR (Status)) {\r
4225 ReturnStatus = Status;\r
4226 }\r
4227 }\r
4228 //\r
4229 // There is no DevNullTextOutTestString () since a Unicode buffer would\r
4230 // always return EFI_SUCCESS.\r
4231 // ReturnStatus will be EFI_SUCCESS if no consoles are present\r
4232 //\r
4233 return ReturnStatus;\r
4234}\r
4235\r
4236\r
4237/**\r
4238 Returns information for an available text mode that the output device(s)\r
4239 supports.\r
4240\r
4241 @param This Protocol instance pointer.\r
4242 @param ModeNumber The mode number to return information on.\r
4243 @param Columns Returns the columns of the text output device\r
4244 for the requested ModeNumber.\r
4245 @param Rows Returns the rows of the text output device\r
4246 for the requested ModeNumber.\r
4247\r
4248 @retval EFI_SUCCESS The requested mode information was returned.\r
4249 @retval EFI_DEVICE_ERROR The device had an error and could not complete\r
4250 the request.\r
4251 @retval EFI_UNSUPPORTED The mode number was not valid.\r
4252\r
4253**/\r
4254EFI_STATUS\r
4255EFIAPI\r
4256ConSplitterTextOutQueryMode (\r
4257 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,\r
4258 IN UINTN ModeNumber,\r
4259 OUT UINTN *Columns,\r
4260 OUT UINTN *Rows\r
4261 )\r
4262{\r
4263 TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;\r
4264 UINTN CurrentMode;\r
4265 INT32 *TextOutModeMap;\r
4266\r
4267 Private = TEXT_OUT_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
4268\r
4269 //\r
4270 // Check whether param ModeNumber is valid.\r
4271 // ModeNumber should be within range 0 ~ MaxMode - 1.\r
4272 //\r
4273 if ( (ModeNumber > (UINTN)(((UINT32)-1)>>1)) ) {\r
4274 return EFI_UNSUPPORTED;\r
4275 }\r
4276\r
4277 if ((INT32) ModeNumber >= This->Mode->MaxMode) {\r
4278 return EFI_UNSUPPORTED;\r
4279 }\r
4280\r
4281 //\r
4282 // We get the available mode from mode intersection map if it's available\r
4283 //\r
4284 if (Private->TextOutModeMap != NULL) {\r
4285 TextOutModeMap = Private->TextOutModeMap + Private->TextOutListCount * ModeNumber;\r
4286 CurrentMode = (UINTN)(*TextOutModeMap);\r
4287 *Columns = Private->TextOutQueryData[CurrentMode].Columns;\r
4288 *Rows = Private->TextOutQueryData[CurrentMode].Rows;\r
4289 } else {\r
4290 *Columns = Private->TextOutQueryData[ModeNumber].Columns;\r
4291 *Rows = Private->TextOutQueryData[ModeNumber].Rows;\r
4292 }\r
4293\r
4294 if (*Columns <= 0 && *Rows <= 0) {\r
4295 return EFI_UNSUPPORTED;\r
4296\r
4297 }\r
4298\r
4299 return EFI_SUCCESS;\r
4300}\r
4301\r
4302\r
4303/**\r
4304 Sets the output device(s) to a specified mode.\r
4305\r
4306 @param This Protocol instance pointer.\r
4307 @param ModeNumber The mode number to set.\r
4308\r
4309 @retval EFI_SUCCESS The requested text mode was set.\r
4310 @retval EFI_DEVICE_ERROR The device had an error and could not complete\r
4311 the request.\r
4312 @retval EFI_UNSUPPORTED The mode number was not valid.\r
4313\r
4314**/\r
4315EFI_STATUS\r
4316EFIAPI\r
4317ConSplitterTextOutSetMode (\r
4318 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,\r
4319 IN UINTN ModeNumber\r
4320 )\r
4321{\r
4322 EFI_STATUS Status;\r
4323 TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;\r
4324 UINTN Index;\r
4325 INT32 *TextOutModeMap;\r
4326 EFI_STATUS ReturnStatus;\r
4327\r
4328 Private = TEXT_OUT_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
4329\r
4330 //\r
4331 // Check whether param ModeNumber is valid.\r
4332 // ModeNumber should be within range 0 ~ MaxMode - 1.\r
4333 //\r
4334 if ( (ModeNumber > (UINTN)(((UINT32)-1)>>1)) ) {\r
4335 return EFI_UNSUPPORTED;\r
4336 }\r
4337\r
4338 if ((INT32) ModeNumber >= This->Mode->MaxMode) {\r
4339 return EFI_UNSUPPORTED;\r
4340 }\r
4341 //\r
4342 // If the mode is being set to the curent mode, then just clear the screen and return.\r
4343 //\r
4344 if (Private->TextOutMode.Mode == (INT32) ModeNumber) {\r
4345 return ConSplitterTextOutClearScreen (This);\r
4346 }\r
4347 //\r
4348 // return the worst status met\r
4349 //\r
4350 TextOutModeMap = Private->TextOutModeMap + Private->TextOutListCount * ModeNumber;\r
4351 for (Index = 0, ReturnStatus = EFI_SUCCESS; Index < Private->CurrentNumberOfConsoles; Index++) {\r
4352 Status = Private->TextOutList[Index].TextOut->SetMode (\r
4353 Private->TextOutList[Index].TextOut,\r
4354 TextOutModeMap[Index]\r
4355 );\r
4356 //\r
4357 // If this console device is based on a GOP or UGA device, then sync up the bitmap from\r
4358 // the GOP/UGA splitter and reclear the text portion of the display in the new mode.\r
4359 //\r
4360 if ((Private->TextOutList[Index].GraphicsOutput != NULL) || (Private->TextOutList[Index].UgaDraw != NULL)) {\r
4361 Private->TextOutList[Index].TextOut->ClearScreen (Private->TextOutList[Index].TextOut);\r
4362 }\r
4363\r
4364 if (EFI_ERROR (Status)) {\r
4365 ReturnStatus = Status;\r
4366 }\r
4367 }\r
4368\r
4369 //\r
4370 // Set mode parameter to specified mode number\r
4371 //\r
4372 TextOutSetMode (Private, ModeNumber);\r
4373\r
4374 return ReturnStatus;\r
4375}\r
4376\r
4377\r
4378/**\r
4379 Sets the background and foreground colors for the OutputString () and\r
4380 ClearScreen () functions.\r
4381\r
4382 @param This Protocol instance pointer.\r
4383 @param Attribute The attribute to set. Bits 0..3 are the\r
4384 foreground color, and bits 4..6 are the\r
4385 background color. All other bits are undefined\r
4386 and must be zero. The valid Attributes are\r
4387 defined in this file.\r
4388\r
4389 @retval EFI_SUCCESS The attribute was set.\r
4390 @retval EFI_DEVICE_ERROR The device had an error and could not complete\r
4391 the request.\r
4392 @retval EFI_UNSUPPORTED The attribute requested is not defined.\r
4393\r
4394**/\r
4395EFI_STATUS\r
4396EFIAPI\r
4397ConSplitterTextOutSetAttribute (\r
4398 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,\r
4399 IN UINTN Attribute\r
4400 )\r
4401{\r
4402 EFI_STATUS Status;\r
4403 TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;\r
4404 UINTN Index;\r
4405 EFI_STATUS ReturnStatus;\r
4406\r
4407 Private = TEXT_OUT_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
4408\r
4409 //\r
4410 // Check whether param Attribute is valid.\r
4411 //\r
4412 if ( (Attribute > (UINTN)(((UINT32)-1)>>1)) ) {\r
4413 return EFI_UNSUPPORTED;\r
4414 }\r
4415\r
4416 //\r
4417 // return the worst status met\r
4418 //\r
4419 for (Index = 0, ReturnStatus = EFI_SUCCESS; Index < Private->CurrentNumberOfConsoles; Index++) {\r
4420 Status = Private->TextOutList[Index].TextOut->SetAttribute (\r
4421 Private->TextOutList[Index].TextOut,\r
4422 Attribute\r
4423 );\r
4424 if (EFI_ERROR (Status)) {\r
4425 ReturnStatus = Status;\r
4426 }\r
4427 }\r
4428\r
4429 Private->TextOutMode.Attribute = (INT32) Attribute;\r
4430\r
4431 return ReturnStatus;\r
4432}\r
4433\r
4434\r
4435/**\r
4436 Clears the output device(s) display to the currently selected background\r
4437 color.\r
4438\r
4439 @param This Protocol instance pointer.\r
4440\r
4441 @retval EFI_SUCCESS The operation completed successfully.\r
4442 @retval EFI_DEVICE_ERROR The device had an error and could not complete\r
4443 the request.\r
4444 @retval EFI_UNSUPPORTED The output device is not in a valid text mode.\r
4445\r
4446**/\r
4447EFI_STATUS\r
4448EFIAPI\r
4449ConSplitterTextOutClearScreen (\r
4450 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This\r
4451 )\r
4452{\r
4453 EFI_STATUS Status;\r
4454 TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;\r
4455 UINTN Index;\r
4456 EFI_STATUS ReturnStatus;\r
4457\r
4458 Private = TEXT_OUT_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
4459\r
4460 //\r
4461 // return the worst status met\r
4462 //\r
4463 for (Index = 0, ReturnStatus = EFI_SUCCESS; Index < Private->CurrentNumberOfConsoles; Index++) {\r
4464 Status = Private->TextOutList[Index].TextOut->ClearScreen (Private->TextOutList[Index].TextOut);\r
4465 if (EFI_ERROR (Status)) {\r
4466 ReturnStatus = Status;\r
4467 }\r
4468 }\r
4469\r
4470 //\r
4471 // No need to do extra check here as whether (Column, Row) is valid has\r
4472 // been checked in ConSplitterTextOutSetCursorPosition. And (0, 0) should\r
4473 // always be supported.\r
4474 //\r
4475 Private->TextOutMode.CursorColumn = 0;\r
4476 Private->TextOutMode.CursorRow = 0;\r
4477 Private->TextOutMode.CursorVisible = TRUE;\r
4478\r
4479 return ReturnStatus;\r
4480}\r
4481\r
4482\r
4483/**\r
4484 Sets the current coordinates of the cursor position\r
4485\r
4486 @param This Protocol instance pointer.\r
4487 @param Column The column position to set the cursor to. Must be\r
4488 greater than or equal to zero and less than the\r
4489 number of columns by QueryMode ().\r
4490 @param Row The row position to set the cursor to. Must be\r
4491 greater than or equal to zero and less than the\r
4492 number of rows by QueryMode ().\r
4493\r
4494 @retval EFI_SUCCESS The operation completed successfully.\r
4495 @retval EFI_DEVICE_ERROR The device had an error and could not complete\r
4496 the request.\r
4497 @retval EFI_UNSUPPORTED The output device is not in a valid text mode,\r
4498 or the cursor position is invalid for the\r
4499 current mode.\r
4500\r
4501**/\r
4502EFI_STATUS\r
4503EFIAPI\r
4504ConSplitterTextOutSetCursorPosition (\r
4505 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,\r
4506 IN UINTN Column,\r
4507 IN UINTN Row\r
4508 )\r
4509{\r
4510 EFI_STATUS Status;\r
4511 TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;\r
4512 UINTN Index;\r
4513 EFI_STATUS ReturnStatus;\r
4514 UINTN MaxColumn;\r
4515 UINTN MaxRow;\r
4516 INT32 *TextOutModeMap;\r
4517 INT32 ModeNumber;\r
4518 INT32 CurrentMode;\r
4519\r
4520 Private = TEXT_OUT_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
4521 TextOutModeMap = NULL;\r
4522 ModeNumber = Private->TextOutMode.Mode;\r
4523\r
4524 //\r
4525 // Get current MaxColumn and MaxRow from intersection map\r
4526 //\r
4527 if (Private->TextOutModeMap != NULL) {\r
4528 TextOutModeMap = Private->TextOutModeMap + Private->TextOutListCount * ModeNumber;\r
4529 CurrentMode = *TextOutModeMap;\r
4530 } else {\r
4531 CurrentMode = ModeNumber;\r
4532 }\r
4533\r
4534 MaxColumn = Private->TextOutQueryData[CurrentMode].Columns;\r
4535 MaxRow = Private->TextOutQueryData[CurrentMode].Rows;\r
4536\r
4537 if (Column >= MaxColumn || Row >= MaxRow) {\r
4538 return EFI_UNSUPPORTED;\r
4539 }\r
4540 //\r
4541 // return the worst status met\r
4542 //\r
4543 for (Index = 0, ReturnStatus = EFI_SUCCESS; Index < Private->CurrentNumberOfConsoles; Index++) {\r
4544 Status = Private->TextOutList[Index].TextOut->SetCursorPosition (\r
4545 Private->TextOutList[Index].TextOut,\r
4546 Column,\r
4547 Row\r
4548 );\r
4549 if (EFI_ERROR (Status)) {\r
4550 ReturnStatus = Status;\r
4551 }\r
4552 }\r
4553\r
4554 //\r
4555 // No need to do extra check here as whether (Column, Row) is valid has\r
4556 // been checked in ConSplitterTextOutSetCursorPosition. And (0, 0) should\r
4557 // always be supported.\r
4558 //\r
4559 Private->TextOutMode.CursorColumn = (INT32) Column;\r
4560 Private->TextOutMode.CursorRow = (INT32) Row;\r
4561\r
4562 return ReturnStatus;\r
4563}\r
4564\r
4565\r
4566/**\r
4567 Makes the cursor visible or invisible\r
4568\r
4569 @param This Protocol instance pointer.\r
4570 @param Visible If TRUE, the cursor is set to be visible. If\r
4571 FALSE, the cursor is set to be invisible.\r
4572\r
4573 @retval EFI_SUCCESS The operation completed successfully.\r
4574 @retval EFI_DEVICE_ERROR The device had an error and could not complete\r
4575 the request, or the device does not support\r
4576 changing the cursor mode.\r
4577 @retval EFI_UNSUPPORTED The output device is not in a valid text mode.\r
4578\r
4579**/\r
4580EFI_STATUS\r
4581EFIAPI\r
4582ConSplitterTextOutEnableCursor (\r
4583 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,\r
4584 IN BOOLEAN Visible\r
4585 )\r
4586{\r
4587 EFI_STATUS Status;\r
4588 TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;\r
4589 UINTN Index;\r
4590 EFI_STATUS ReturnStatus;\r
4591\r
4592 Private = TEXT_OUT_SPLITTER_PRIVATE_DATA_FROM_THIS (This);\r
4593\r
4594 //\r
4595 // return the worst status met\r
4596 //\r
4597 for (Index = 0, ReturnStatus = EFI_SUCCESS; Index < Private->CurrentNumberOfConsoles; Index++) {\r
4598 Status = Private->TextOutList[Index].TextOut->EnableCursor (\r
4599 Private->TextOutList[Index].TextOut,\r
4600 Visible\r
4601 );\r
4602 if (EFI_ERROR (Status)) {\r
4603 ReturnStatus = Status;\r
4604 }\r
4605 }\r
4606\r
4607 Private->TextOutMode.CursorVisible = Visible;\r
4608\r
4609 return ReturnStatus;\r
4610}\r
4611\r
EFI Development Kit II mirror for PVE