9ad1726599cd802addc264383d957dcd87aea649
[mirror_edk2.git] / Vlv2TbltDevicePkg / Override / MdeModulePkg / Universal / Console / ConSplitterDxe / ComponentName.c
1 /** @file
2 UEFI Component Name(2) protocol implementation for ConSplitter driver.
3
4 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "ConSplitter.h"
16
17 //
18 // EFI Component Name Protocol
19 //
20 GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL gConSplitterConInComponentName = {
21 ConSplitterComponentNameGetDriverName,
22 ConSplitterConInComponentNameGetControllerName,
23 "eng"
24 };
25
26 //
27 // EFI Component Name 2 Protocol
28 //
29 GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gConSplitterConInComponentName2 = {
30 (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) ConSplitterComponentNameGetDriverName,
31 (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) ConSplitterConInComponentNameGetControllerName,
32 "en"
33 };
34
35
36 //
37 // EFI Component Name Protocol
38 //
39 GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL gConSplitterSimplePointerComponentName = {
40 ConSplitterComponentNameGetDriverName,
41 ConSplitterSimplePointerComponentNameGetControllerName,
42 "eng"
43 };
44
45 //
46 // EFI Component Name 2 Protocol
47 //
48 GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gConSplitterSimplePointerComponentName2 = {
49 (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) ConSplitterComponentNameGetDriverName,
50 (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) ConSplitterSimplePointerComponentNameGetControllerName,
51 "en"
52 };
53
54 //
55 // EFI Component Name Protocol
56 //
57 GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL gConSplitterAbsolutePointerComponentName = {
58 ConSplitterComponentNameGetDriverName,
59 ConSplitterAbsolutePointerComponentNameGetControllerName,
60 "eng"
61 };
62
63 //
64 // EFI Component Name 2 Protocol
65 //
66 GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gConSplitterAbsolutePointerComponentName2 = {
67 (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) ConSplitterComponentNameGetDriverName,
68 (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) ConSplitterAbsolutePointerComponentNameGetControllerName,
69 "en"
70 };
71
72 //
73 // EFI Component Name Protocol
74 //
75 GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL gConSplitterConOutComponentName = {
76 ConSplitterComponentNameGetDriverName,
77 ConSplitterConOutComponentNameGetControllerName,
78 "eng"
79 };
80
81 //
82 // EFI Component Name 2 Protocol
83 //
84 GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gConSplitterConOutComponentName2 = {
85 (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) ConSplitterComponentNameGetDriverName,
86 (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) ConSplitterConOutComponentNameGetControllerName,
87 "en"
88 };
89
90
91 //
92 // EFI Component Name Protocol
93 //
94 GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL gConSplitterStdErrComponentName = {
95 ConSplitterComponentNameGetDriverName,
96 ConSplitterStdErrComponentNameGetControllerName,
97 "eng"
98 };
99
100 //
101 // EFI Component Name 2 Protocol
102 //
103 GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gConSplitterStdErrComponentName2 = {
104 (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) ConSplitterComponentNameGetDriverName,
105 (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) ConSplitterStdErrComponentNameGetControllerName,
106 "en"
107 };
108
109
110 GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mConSplitterDriverNameTable[] = {
111 {
112 "eng;en",
113 (CHAR16 *) L"Console Splitter Driver"
114 },
115 {
116 NULL,
117 NULL
118 }
119 };
120
121 GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mConSplitterConInControllerNameTable[] = {
122 {
123 "eng;en",
124 (CHAR16 *) L"Primary Console Input Device"
125 },
126 {
127 NULL,
128 NULL
129 }
130 };
131
132 GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mConSplitterSimplePointerControllerNameTable[] = {
133 {
134 "eng;en",
135 (CHAR16 *) L"Primary Simple Pointer Device"
136 },
137 {
138 NULL,
139 NULL
140 }
141 };
142
143 GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mConSplitterAbsolutePointerControllerNameTable[] = {
144 {
145 "eng;en",
146 (CHAR16 *)L"Primary Absolute Pointer Device"
147 },
148 {
149 NULL,
150 NULL
151 }
152 };
153
154 GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mConSplitterConOutControllerNameTable[] = {
155 {
156 "eng;en",
157 (CHAR16 *) L"Primary Console Output Device"
158 },
159 {
160 NULL,
161 NULL
162 }
163 };
164
165 GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mConSplitterStdErrControllerNameTable[] = {
166 {
167 "eng;en",
168 (CHAR16 *) L"Primary Standard Error Device"
169 },
170 {
171 NULL,
172 NULL
173 }
174 };
175
176 /**
177 Retrieves a Unicode string that is the user readable name of the driver.
178
179 This function retrieves the user readable name of a driver in the form of a
180 Unicode string. If the driver specified by This has a user readable name in
181 the language specified by Language, then a pointer to the driver name is
182 returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
183 by This does not support the language specified by Language,
184 then EFI_UNSUPPORTED is returned.
185
186 @param This[in] A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
187 EFI_COMPONENT_NAME_PROTOCOL instance.
188
189 @param Language[in] A pointer to a Null-terminated ASCII string
190 array indicating the language. This is the
191 language of the driver name that the caller is
192 requesting, and it must match one of the
193 languages specified in SupportedLanguages. The
194 number of languages supported by a driver is up
195 to the driver writer. Language is specified
196 in RFC 4646 or ISO 639-2 language code format.
197
198 @param DriverName[out] A pointer to the Unicode string to return.
199 This Unicode string is the name of the
200 driver specified by This in the language
201 specified by Language.
202
203 @retval EFI_SUCCESS The Unicode string for the Driver specified by
204 This and the language specified by Language was
205 returned in DriverName.
206
207 @retval EFI_INVALID_PARAMETER Language is NULL.
208
209 @retval EFI_INVALID_PARAMETER DriverName is NULL.
210
211 @retval EFI_UNSUPPORTED The driver specified by This does not support
212 the language specified by Language.
213
214 **/
215 EFI_STATUS
216 EFIAPI
217 ConSplitterComponentNameGetDriverName (
218 IN EFI_COMPONENT_NAME_PROTOCOL *This,
219 IN CHAR8 *Language,
220 OUT CHAR16 **DriverName
221 )
222 {
223 return LookupUnicodeString2 (
224 Language,
225 This->SupportedLanguages,
226 mConSplitterDriverNameTable,
227 DriverName,
228 (BOOLEAN)((This == &gConSplitterConInComponentName) ||
229 (This == &gConSplitterSimplePointerComponentName) ||
230 (This == &gConSplitterAbsolutePointerComponentName) ||
231 (This == &gConSplitterConOutComponentName) ||
232 (This == &gConSplitterStdErrComponentName))
233 );
234 }
235
236 /**
237 Tests whether a controller handle is being managed by a specific driver and
238 the child handle is a child device of the controller.
239
240 @param ControllerHandle A handle for a controller to test.
241 @param DriverBindingHandle Specifies the driver binding handle for the
242 driver.
243 @param ProtocolGuid Specifies the protocol that the driver specified
244 by DriverBindingHandle opens in its Start()
245 function.
246 @param ChildHandle A child handle to test.
247 @param ConsumsedGuid Supplies the protocol that the child controller
248 opens on its parent controller.
249
250 @retval EFI_SUCCESS ControllerHandle is managed by the driver
251 specifed by DriverBindingHandle and ChildHandle
252 is a child of the ControllerHandle.
253 @retval EFI_UNSUPPORTED ControllerHandle is not managed by the driver
254 specifed by DriverBindingHandle.
255 @retval EFI_UNSUPPORTED ChildHandle is not a child of the
256 ControllerHandle.
257
258 **/
259 EFI_STATUS
260 ConSplitterTestControllerHandles (
261 IN CONST EFI_HANDLE ControllerHandle,
262 IN CONST EFI_HANDLE DriverBindingHandle,
263 IN CONST EFI_GUID *ProtocolGuid,
264 IN EFI_HANDLE ChildHandle,
265 IN CONST EFI_GUID *ConsumsedGuid
266 )
267 {
268 EFI_STATUS Status;
269
270 //
271 // here ChildHandle is not an Optional parameter.
272 //
273 if (ChildHandle == NULL) {
274 return EFI_UNSUPPORTED;
275 }
276
277 //
278 // Tests whether a controller handle is being managed by a specific driver.
279 //
280 Status = EfiTestManagedDevice (
281 ControllerHandle,
282 DriverBindingHandle,
283 ProtocolGuid
284 );
285 if (EFI_ERROR (Status)) {
286 return Status;
287 }
288
289 //
290 // Tests whether a child handle is a child device of the controller.
291 //
292 Status = EfiTestChildHandle (
293 ControllerHandle,
294 ChildHandle,
295 ConsumsedGuid
296 );
297
298 return Status;
299 }
300
301 /**
302 Retrieves a Unicode string that is the user readable name of the controller
303 that is being managed by a driver.
304
305 This function retrieves the user readable name of the controller specified by
306 ControllerHandle and ChildHandle in the form of a Unicode string. If the
307 driver specified by This has a user readable name in the language specified by
308 Language, then a pointer to the controller name is returned in ControllerName,
309 and EFI_SUCCESS is returned. If the driver specified by This is not currently
310 managing the controller specified by ControllerHandle and ChildHandle,
311 then EFI_UNSUPPORTED is returned. If the driver specified by This does not
312 support the language specified by Language, then EFI_UNSUPPORTED is returned.
313
314 @param This[in] A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
315 EFI_COMPONENT_NAME_PROTOCOL instance.
316
317 @param ControllerHandle[in] The handle of a controller that the driver
318 specified by This is managing. This handle
319 specifies the controller whose name is to be
320 returned.
321
322 @param ChildHandle[in] The handle of the child controller to retrieve
323 the name of. This is an optional parameter that
324 may be NULL. It will be NULL for device
325 drivers. It will also be NULL for a bus drivers
326 that wish to retrieve the name of the bus
327 controller. It will not be NULL for a bus
328 driver that wishes to retrieve the name of a
329 child controller.
330
331 @param Language[in] A pointer to a Null-terminated ASCII string
332 array indicating the language. This is the
333 language of the driver name that the caller is
334 requesting, and it must match one of the
335 languages specified in SupportedLanguages. The
336 number of languages supported by a driver is up
337 to the driver writer. Language is specified in
338 RFC 4646 or ISO 639-2 language code format.
339
340 @param ControllerName[out] A pointer to the Unicode string to return.
341 This Unicode string is the name of the
342 controller specified by ControllerHandle and
343 ChildHandle in the language specified by
344 Language from the point of view of the driver
345 specified by This.
346
347 @retval EFI_SUCCESS The Unicode string for the user readable name in
348 the language specified by Language for the
349 driver specified by This was returned in
350 DriverName.
351
352 @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
353
354 @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
355 EFI_HANDLE.
356
357 @retval EFI_INVALID_PARAMETER Language is NULL.
358
359 @retval EFI_INVALID_PARAMETER ControllerName is NULL.
360
361 @retval EFI_UNSUPPORTED The driver specified by This is not currently
362 managing the controller specified by
363 ControllerHandle and ChildHandle.
364
365 @retval EFI_UNSUPPORTED The driver specified by This does not support
366 the language specified by Language.
367
368 **/
369 EFI_STATUS
370 EFIAPI
371 ConSplitterConInComponentNameGetControllerName (
372 IN EFI_COMPONENT_NAME_PROTOCOL *This,
373 IN EFI_HANDLE ControllerHandle,
374 IN EFI_HANDLE ChildHandle OPTIONAL,
375 IN CHAR8 *Language,
376 OUT CHAR16 **ControllerName
377 )
378 {
379 EFI_STATUS Status;
380
381 Status = ConSplitterTestControllerHandles (
382 ControllerHandle,
383 gConSplitterConInDriverBinding.DriverBindingHandle,
384 &gEfiConsoleInDeviceGuid,
385 ChildHandle,
386 &gEfiConsoleInDeviceGuid
387 );
388 if (EFI_ERROR (Status)) {
389 return Status;
390 }
391
392 return LookupUnicodeString2 (
393 Language,
394 This->SupportedLanguages,
395 mConSplitterConInControllerNameTable,
396 ControllerName,
397 (BOOLEAN)(This == &gConSplitterConInComponentName)
398 );
399 }
400
401 /**
402 Retrieves a Unicode string that is the user readable name of the controller
403 that is being managed by a driver.
404
405 This function retrieves the user readable name of the controller specified by
406 ControllerHandle and ChildHandle in the form of a Unicode string. If the
407 driver specified by This has a user readable name in the language specified by
408 Language, then a pointer to the controller name is returned in ControllerName,
409 and EFI_SUCCESS is returned. If the driver specified by This is not currently
410 managing the controller specified by ControllerHandle and ChildHandle,
411 then EFI_UNSUPPORTED is returned. If the driver specified by This does not
412 support the language specified by Language, then EFI_UNSUPPORTED is returned.
413
414 @param This[in] A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
415 EFI_COMPONENT_NAME_PROTOCOL instance.
416
417 @param ControllerHandle[in] The handle of a controller that the driver
418 specified by This is managing. This handle
419 specifies the controller whose name is to be
420 returned.
421
422 @param ChildHandle[in] The handle of the child controller to retrieve
423 the name of. This is an optional parameter that
424 may be NULL. It will be NULL for device
425 drivers. It will also be NULL for a bus drivers
426 that wish to retrieve the name of the bus
427 controller. It will not be NULL for a bus
428 driver that wishes to retrieve the name of a
429 child controller.
430
431 @param Language[in] A pointer to a Null-terminated ASCII string
432 array indicating the language. This is the
433 language of the driver name that the caller is
434 requesting, and it must match one of the
435 languages specified in SupportedLanguages. The
436 number of languages supported by a driver is up
437 to the driver writer. Language is specified in
438 RFC 4646 or ISO 639-2 language code format.
439
440 @param ControllerName[out] A pointer to the Unicode string to return.
441 This Unicode string is the name of the
442 controller specified by ControllerHandle and
443 ChildHandle in the language specified by
444 Language from the point of view of the driver
445 specified by This.
446
447 @retval EFI_SUCCESS The Unicode string for the user readable name in
448 the language specified by Language for the
449 driver specified by This was returned in
450 DriverName.
451
452 @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
453
454 @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
455 EFI_HANDLE.
456
457 @retval EFI_INVALID_PARAMETER Language is NULL.
458
459 @retval EFI_INVALID_PARAMETER ControllerName is NULL.
460
461 @retval EFI_UNSUPPORTED The driver specified by This is not currently
462 managing the controller specified by
463 ControllerHandle and ChildHandle.
464
465 @retval EFI_UNSUPPORTED The driver specified by This does not support
466 the language specified by Language.
467
468 **/
469 EFI_STATUS
470 EFIAPI
471 ConSplitterSimplePointerComponentNameGetControllerName (
472 IN EFI_COMPONENT_NAME_PROTOCOL *This,
473 IN EFI_HANDLE ControllerHandle,
474 IN EFI_HANDLE ChildHandle OPTIONAL,
475 IN CHAR8 *Language,
476 OUT CHAR16 **ControllerName
477 )
478 {
479 EFI_STATUS Status;
480
481 Status = ConSplitterTestControllerHandles (
482 ControllerHandle,
483 gConSplitterSimplePointerDriverBinding.DriverBindingHandle,
484 &gEfiSimplePointerProtocolGuid,
485 ChildHandle,
486 &gEfiSimplePointerProtocolGuid
487 );
488 if (EFI_ERROR (Status)) {
489 return Status;
490 }
491
492 return LookupUnicodeString2 (
493 Language,
494 This->SupportedLanguages,
495 mConSplitterSimplePointerControllerNameTable,
496 ControllerName,
497 (BOOLEAN)(This == &gConSplitterSimplePointerComponentName)
498 );
499 }
500
501
502 /**
503 Retrieves a Unicode string that is the user readable name of the controller
504 that is being managed by an EFI Driver.
505
506 @param This A pointer to the EFI_COMPONENT_NAME_PROTOCOL
507 instance.
508 @param ControllerHandle The handle of a controller that the driver
509 specified by This is managing. This handle
510 specifies the controller whose name is to be
511 returned.
512 @param ChildHandle The handle of the child controller to retrieve the
513 name of. This is an optional parameter that may
514 be NULL. It will be NULL for device drivers. It
515 will also be NULL for a bus drivers that wish to
516 retrieve the name of the bus controller. It will
517 not be NULL for a bus driver that wishes to
518 retrieve the name of a child controller.
519 @param Language A pointer to RFC4646 language identifier. This is
520 the language of the controller name that that the
521 caller is requesting, and it must match one of the
522 languages specified in SupportedLanguages. The
523 number of languages supported by a driver is up to
524 the driver writer.
525 @param ControllerName A pointer to the Unicode string to return. This
526 Unicode string is the name of the controller
527 specified by ControllerHandle and ChildHandle in
528 the language specified by Language from the point
529 of view of the driver specified by This.
530
531 @retval EFI_SUCCESS The Unicode string for the user readable name in
532 the language specified by Language for the driver
533 specified by This was returned in DriverName.
534 @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
535 @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
536 EFI_HANDLE.
537 @retval EFI_INVALID_PARAMETER Language is NULL.
538 @retval EFI_INVALID_PARAMETER ControllerName is NULL.
539 @retval EFI_UNSUPPORTED The driver specified by This is not currently
540 managing the controller specified by
541 ControllerHandle and ChildHandle.
542 @retval EFI_UNSUPPORTED The driver specified by This does not support the
543 language specified by Language.
544
545 **/
546 EFI_STATUS
547 EFIAPI
548 ConSplitterAbsolutePointerComponentNameGetControllerName (
549 IN EFI_COMPONENT_NAME_PROTOCOL *This,
550 IN EFI_HANDLE ControllerHandle,
551 IN EFI_HANDLE ChildHandle OPTIONAL,
552 IN CHAR8 *Language,
553 OUT CHAR16 **ControllerName
554 )
555 {
556 EFI_STATUS Status;
557
558 Status = ConSplitterTestControllerHandles (
559 ControllerHandle,
560 gConSplitterAbsolutePointerDriverBinding.DriverBindingHandle,
561 &gEfiAbsolutePointerProtocolGuid,
562 ChildHandle,
563 &gEfiAbsolutePointerProtocolGuid
564 );
565 if (EFI_ERROR (Status)) {
566 return Status;
567 }
568
569 return LookupUnicodeString2 (
570 Language,
571 This->SupportedLanguages,
572 mConSplitterAbsolutePointerControllerNameTable,
573 ControllerName,
574 (BOOLEAN)(This == &gConSplitterAbsolutePointerComponentName)
575 );
576 }
577
578 /**
579 Retrieves a Unicode string that is the user readable name of the controller
580 that is being managed by a driver.
581
582 This function retrieves the user readable name of the controller specified by
583 ControllerHandle and ChildHandle in the form of a Unicode string. If the
584 driver specified by This has a user readable name in the language specified by
585 Language, then a pointer to the controller name is returned in ControllerName,
586 and EFI_SUCCESS is returned. If the driver specified by This is not currently
587 managing the controller specified by ControllerHandle and ChildHandle,
588 then EFI_UNSUPPORTED is returned. If the driver specified by This does not
589 support the language specified by Language, then EFI_UNSUPPORTED is returned.
590
591 @param This[in] A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
592 EFI_COMPONENT_NAME_PROTOCOL instance.
593
594 @param ControllerHandle[in] The handle of a controller that the driver
595 specified by This is managing. This handle
596 specifies the controller whose name is to be
597 returned.
598
599 @param ChildHandle[in] The handle of the child controller to retrieve
600 the name of. This is an optional parameter that
601 may be NULL. It will be NULL for device
602 drivers. It will also be NULL for a bus drivers
603 that wish to retrieve the name of the bus
604 controller. It will not be NULL for a bus
605 driver that wishes to retrieve the name of a
606 child controller.
607
608 @param Language[in] A pointer to a Null-terminated ASCII string
609 array indicating the language. This is the
610 language of the driver name that the caller is
611 requesting, and it must match one of the
612 languages specified in SupportedLanguages. The
613 number of languages supported by a driver is up
614 to the driver writer. Language is specified in
615 RFC 4646 or ISO 639-2 language code format.
616
617 @param ControllerName[out] A pointer to the Unicode string to return.
618 This Unicode string is the name of the
619 controller specified by ControllerHandle and
620 ChildHandle in the language specified by
621 Language from the point of view of the driver
622 specified by This.
623
624 @retval EFI_SUCCESS The Unicode string for the user readable name in
625 the language specified by Language for the
626 driver specified by This was returned in
627 DriverName.
628
629 @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
630
631 @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
632 EFI_HANDLE.
633
634 @retval EFI_INVALID_PARAMETER Language is NULL.
635
636 @retval EFI_INVALID_PARAMETER ControllerName is NULL.
637
638 @retval EFI_UNSUPPORTED The driver specified by This is not currently
639 managing the controller specified by
640 ControllerHandle and ChildHandle.
641
642 @retval EFI_UNSUPPORTED The driver specified by This does not support
643 the language specified by Language.
644
645 **/
646 EFI_STATUS
647 EFIAPI
648 ConSplitterConOutComponentNameGetControllerName (
649 IN EFI_COMPONENT_NAME_PROTOCOL *This,
650 IN EFI_HANDLE ControllerHandle,
651 IN EFI_HANDLE ChildHandle OPTIONAL,
652 IN CHAR8 *Language,
653 OUT CHAR16 **ControllerName
654 )
655 {
656 EFI_STATUS Status;
657
658 Status = ConSplitterTestControllerHandles (
659 ControllerHandle,
660 gConSplitterConOutDriverBinding.DriverBindingHandle,
661 &gEfiConsoleOutDeviceGuid,
662 ChildHandle,
663 &gEfiConsoleOutDeviceGuid
664 );
665 if (EFI_ERROR (Status)) {
666 return Status;
667 }
668
669 return LookupUnicodeString2 (
670 Language,
671 This->SupportedLanguages,
672 mConSplitterConOutControllerNameTable,
673 ControllerName,
674 (BOOLEAN)(This == &gConSplitterConOutComponentName)
675 );
676 }
677
678 /**
679 Retrieves a Unicode string that is the user readable name of the controller
680 that is being managed by a driver.
681
682 This function retrieves the user readable name of the controller specified by
683 ControllerHandle and ChildHandle in the form of a Unicode string. If the
684 driver specified by This has a user readable name in the language specified by
685 Language, then a pointer to the controller name is returned in ControllerName,
686 and EFI_SUCCESS is returned. If the driver specified by This is not currently
687 managing the controller specified by ControllerHandle and ChildHandle,
688 then EFI_UNSUPPORTED is returned. If the driver specified by This does not
689 support the language specified by Language, then EFI_UNSUPPORTED is returned.
690
691 @param This[in] A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
692 EFI_COMPONENT_NAME_PROTOCOL instance.
693
694 @param ControllerHandle[in] The handle of a controller that the driver
695 specified by This is managing. This handle
696 specifies the controller whose name is to be
697 returned.
698
699 @param ChildHandle[in] The handle of the child controller to retrieve
700 the name of. This is an optional parameter that
701 may be NULL. It will be NULL for device
702 drivers. It will also be NULL for a bus drivers
703 that wish to retrieve the name of the bus
704 controller. It will not be NULL for a bus
705 driver that wishes to retrieve the name of a
706 child controller.
707
708 @param Language[in] A pointer to a Null-terminated ASCII string
709 array indicating the language. This is the
710 language of the driver name that the caller is
711 requesting, and it must match one of the
712 languages specified in SupportedLanguages. The
713 number of languages supported by a driver is up
714 to the driver writer. Language is specified in
715 RFC 4646 or ISO 639-2 language code format.
716
717 @param ControllerName[out] A pointer to the Unicode string to return.
718 This Unicode string is the name of the
719 controller specified by ControllerHandle and
720 ChildHandle in the language specified by
721 Language from the point of view of the driver
722 specified by This.
723
724 @retval EFI_SUCCESS The Unicode string for the user readable name in
725 the language specified by Language for the
726 driver specified by This was returned in
727 DriverName.
728
729 @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
730
731 @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
732 EFI_HANDLE.
733
734 @retval EFI_INVALID_PARAMETER Language is NULL.
735
736 @retval EFI_INVALID_PARAMETER ControllerName is NULL.
737
738 @retval EFI_UNSUPPORTED The driver specified by This is not currently
739 managing the controller specified by
740 ControllerHandle and ChildHandle.
741
742 @retval EFI_UNSUPPORTED The driver specified by This does not support
743 the language specified by Language.
744
745 **/
746 EFI_STATUS
747 EFIAPI
748 ConSplitterStdErrComponentNameGetControllerName (
749 IN EFI_COMPONENT_NAME_PROTOCOL *This,
750 IN EFI_HANDLE ControllerHandle,
751 IN EFI_HANDLE ChildHandle OPTIONAL,
752 IN CHAR8 *Language,
753 OUT CHAR16 **ControllerName
754 )
755 {
756 EFI_STATUS Status;
757
758 Status = ConSplitterTestControllerHandles (
759 ControllerHandle,
760 gConSplitterStdErrDriverBinding.DriverBindingHandle,
761 &gEfiStandardErrorDeviceGuid,
762 ChildHandle,
763 &gEfiStandardErrorDeviceGuid
764 );
765 if (EFI_ERROR (Status)) {
766 return Status;
767 }
768
769 return LookupUnicodeString2 (
770 Language,
771 This->SupportedLanguages,
772 mConSplitterStdErrControllerNameTable,
773 ControllerName,
774 (BOOLEAN)(This == &gConSplitterStdErrComponentName)
775 );
776 }