Home | History | Annotate | Download | only in Udp6Dxe
      1 /** @file
      2   UEFI Component Name(2) protocol implementation for UDP6 driver.
      3 
      4   Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
      5 
      6   This program and the accompanying materials
      7   are licensed and made available under the terms and conditions of the BSD License
      8   which accompanies this distribution.  The full text of the license may be found at
      9   http://opensource.org/licenses/bsd-license.php.
     10 
     11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
     12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
     13 
     14 **/
     15 
     16 #include "Udp6Impl.h"
     17 
     18 //
     19 // EFI Component Name Functions
     20 //
     21 /**
     22   Retrieves a Unicode string that is the user-readable name of the driver.
     23 
     24   This function retrieves the user-readable name of a driver in the form of a
     25   Unicode string. If the driver specified by This has a user-readable name in
     26   the language specified by Language, then a pointer to the driver name is
     27   returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
     28   by This does not support the language specified by Language,
     29   then EFI_UNSUPPORTED is returned.
     30 
     31   @param[in]  This              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
     32                                 EFI_COMPONENT_NAME_PROTOCOL instance.
     33 
     34   @param[in]  Language          A pointer to a Null-terminated ASCII string
     35                                 array indicating the language. This is the
     36                                 language of the driver name that the caller is
     37                                 requesting, and it must match one of the
     38                                 languages specified in SupportedLanguages. The
     39                                 number of languages supported by a driver is up
     40                                 to the driver writer. Language is specified
     41                                 in RFC 4646 or ISO 639-2 language code format.
     42 
     43   @param[out]  DriverName       A pointer to the Unicode string to return.
     44                                 This Unicode string is the name of the
     45                                 driver specified by This in the language
     46                                 specified by Language.
     47 
     48   @retval EFI_SUCCESS           The Unicode string for the Driver specified by
     49                                 This and the language specified by Language was
     50                                 returned in DriverName.
     51 
     52   @retval EFI_INVALID_PARAMETER Language is NULL.
     53 
     54   @retval EFI_INVALID_PARAMETER DriverName is NULL.
     55 
     56   @retval EFI_UNSUPPORTED       The driver specified by This does not support
     57                                 the language specified by Language.
     58 
     59 **/
     60 EFI_STATUS
     61 EFIAPI
     62 Udp6ComponentNameGetDriverName (
     63   IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
     64   IN  CHAR8                        *Language,
     65   OUT CHAR16                       **DriverName
     66   );
     67 
     68 
     69 /**
     70   Retrieves a Unicode string that is the user-readable name of the controller
     71   that is being managed by a driver.
     72 
     73   This function retrieves the user-readable name of the controller specified by
     74   ControllerHandle and ChildHandle in the form of a Unicode string. If the
     75   driver specified by This has a user-readable name in the language specified by
     76   Language, then a pointer to the controller name is returned in ControllerName,
     77   and EFI_SUCCESS is returned.  If the driver specified by This is not currently
     78   managing the controller specified by ControllerHandle and ChildHandle,
     79   then EFI_UNSUPPORTED is returned.  If the driver specified by This does not
     80   support the language specified by Language, then EFI_UNSUPPORTED is returned.
     81 
     82   @param[in]  This              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
     83                                 EFI_COMPONENT_NAME_PROTOCOL instance.
     84 
     85   @param[in]  ControllerHandle  The handle of a controller that the driver
     86                                 specified by This is managing.  This handle
     87                                 specifies the controller whose name is to be
     88                                 returned.
     89 
     90   @param[in]  ChildHandle       The handle of the child controller to retrieve
     91                                 the name of.  This is an optional parameter that
     92                                 may be NULL.  It will be NULL for device
     93                                 drivers.  It will also be NULL for a bus drivers
     94                                 that wish to retrieve the name of the bus
     95                                 controller.  It will not be NULL for a bus
     96                                 driver that wishes to retrieve the name of a
     97                                 child controller.
     98 
     99   @param[in]  Language          A pointer to a Null-terminated ASCII string
    100                                 array indicating the language.  This is the
    101                                 language of the driver name that the caller is
    102                                 requesting, and it must match one of the
    103                                 languages specified in SupportedLanguages. The
    104                                 number of languages supported by a driver is up
    105                                 to the driver writer. Language is specified in
    106                                 RFC 4646 or ISO 639-2 language code format.
    107 
    108   @param[out]  ControllerName   A pointer to the Unicode string to return.
    109                                 This Unicode string is the name of the
    110                                 controller specified by ControllerHandle and
    111                                 ChildHandle in the language specified by
    112                                 Language from the point of view of the driver
    113                                 specified by This.
    114 
    115   @retval EFI_SUCCESS           The Unicode string for the user-readable name in
    116                                 the language specified by Language for the
    117                                 driver specified by This was returned in
    118                                 DriverName.
    119 
    120   @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
    121 
    122   @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
    123                                 EFI_HANDLE.
    124 
    125   @retval EFI_INVALID_PARAMETER Language is NULL.
    126 
    127   @retval EFI_INVALID_PARAMETER ControllerName is NULL.
    128 
    129   @retval EFI_UNSUPPORTED       The driver specified by This is not currently
    130                                 managing the controller specified by
    131                                 ControllerHandle and ChildHandle.
    132 
    133   @retval EFI_UNSUPPORTED       The driver specified by This does not support
    134                                 the language specified by Language.
    135 
    136 **/
    137 EFI_STATUS
    138 EFIAPI
    139 Udp6ComponentNameGetControllerName (
    140   IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
    141   IN  EFI_HANDLE                   ControllerHandle,
    142   IN  EFI_HANDLE                   ChildHandle OPTIONAL,
    143   IN  CHAR8                        *Language,
    144   OUT CHAR16                       **ControllerName
    145   );
    146 
    147 //
    148 // EFI Component Name Protocol
    149 //
    150 GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL  gUdp6ComponentName = {
    151   Udp6ComponentNameGetDriverName,
    152   Udp6ComponentNameGetControllerName,
    153   "eng"
    154 };
    155 
    156 //
    157 // EFI Component Name 2 Protocol
    158 //
    159 GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gUdp6ComponentName2 = {
    160   (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) Udp6ComponentNameGetDriverName,
    161   (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) Udp6ComponentNameGetControllerName,
    162   "en"
    163 };
    164 
    165 
    166 GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mUdp6DriverNameTable[] = {
    167   {
    168     "eng;en",
    169     L"UDP6 Network Service Driver"
    170   },
    171   {
    172     NULL,
    173     NULL
    174   }
    175 };
    176 
    177 GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE  *gUdp6ControllerNameTable = NULL;
    178 
    179 /**
    180   Retrieves a Unicode string that is the user-readable name of the driver.
    181 
    182   This function retrieves the user-readable name of a driver in the form of a
    183   Unicode string. If the driver specified by This has a user-readable name in
    184   the language specified by Language, then a pointer to the driver name is
    185   returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
    186   by This does not support the language specified by Language,
    187   then EFI_UNSUPPORTED is returned.
    188 
    189   @param[in]  This              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
    190                                 EFI_COMPONENT_NAME_PROTOCOL instance.
    191 
    192   @param[in]  Language          A pointer to a Null-terminated ASCII string
    193                                 array indicating the language. This is the
    194                                 language of the driver name that the caller is
    195                                 requesting, and it must match one of the
    196                                 languages specified in SupportedLanguages. The
    197                                 number of languages supported by a driver is up
    198                                 to the driver writer. Language is specified
    199                                 in RFC 4646 or ISO 639-2 language code format.
    200 
    201   @param[out]  DriverName       A pointer to the Unicode string to return.
    202                                 This Unicode string is the name of the
    203                                 driver specified by This in the language
    204                                 specified by Language.
    205 
    206   @retval EFI_SUCCESS           The Unicode string for the Driver specified by
    207                                 This and the language specified by Language was
    208                                 returned in DriverName.
    209 
    210   @retval EFI_INVALID_PARAMETER Language is NULL.
    211 
    212   @retval EFI_INVALID_PARAMETER DriverName is NULL.
    213 
    214   @retval EFI_UNSUPPORTED       The driver specified by This does not support
    215                                 the language specified by Language.
    216 
    217 **/
    218 EFI_STATUS
    219 EFIAPI
    220 Udp6ComponentNameGetDriverName (
    221   IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
    222   IN  CHAR8                        *Language,
    223   OUT CHAR16                       **DriverName
    224   )
    225 {
    226   return LookupUnicodeString2 (
    227            Language,
    228            This->SupportedLanguages,
    229            mUdp6DriverNameTable,
    230            DriverName,
    231            (BOOLEAN) (This == &gUdp6ComponentName)
    232            );
    233 }
    234 
    235 /**
    236   Update the component name for the Udp6 child handle.
    237 
    238   @param  Udp6[in]                  A pointer to the EFI_UDP6_PROTOCOL.
    239 
    240 
    241   @retval EFI_SUCCESS               Update the ControllerNameTable of this instance successfully.
    242   @retval EFI_INVALID_PARAMETER     The input parameter is invalid.
    243 
    244 **/
    245 EFI_STATUS
    246 UpdateName (
    247   IN    EFI_UDP6_PROTOCOL             *Udp6
    248   )
    249 {
    250   EFI_STATUS                       Status;
    251   CHAR16                           HandleName[64];
    252   EFI_UDP6_CONFIG_DATA             Udp6ConfigData;
    253 
    254   if (Udp6 == NULL) {
    255     return EFI_INVALID_PARAMETER;
    256   }
    257 
    258   //
    259   // Format the child name into the string buffer.
    260   //
    261   Status = Udp6->GetModeData (Udp6, &Udp6ConfigData, NULL, NULL, NULL);
    262   if (!EFI_ERROR (Status)) {
    263     UnicodeSPrint (HandleName, sizeof (HandleName),
    264       L"UDPv6 (SrcPort=%d, DestPort=%d)",
    265       Udp6ConfigData.StationPort,
    266       Udp6ConfigData.RemotePort
    267       );
    268   } else if (Status == EFI_NOT_STARTED) {
    269     UnicodeSPrint (HandleName, sizeof (HandleName), L"UDPv6 (Not started)");
    270   } else {
    271     UnicodeSPrint (HandleName, sizeof (HandleName), L"UDPv6 (%r)", Status);
    272   }
    273 
    274   if (gUdp6ControllerNameTable != NULL) {
    275     FreeUnicodeStringTable (gUdp6ControllerNameTable);
    276     gUdp6ControllerNameTable = NULL;
    277   }
    278 
    279   Status = AddUnicodeString2 (
    280              "eng",
    281              gUdp6ComponentName.SupportedLanguages,
    282              &gUdp6ControllerNameTable,
    283              HandleName,
    284              TRUE
    285              );
    286   if (EFI_ERROR (Status)) {
    287     return Status;
    288   }
    289 
    290   return AddUnicodeString2 (
    291            "en",
    292            gUdp6ComponentName2.SupportedLanguages,
    293            &gUdp6ControllerNameTable,
    294            HandleName,
    295            FALSE
    296            );
    297 }
    298 
    299 /**
    300   Retrieves a Unicode string that is the user-readable name of the controller
    301   that is being managed by a driver.
    302 
    303   This function retrieves the user-readable name of the controller specified by
    304   ControllerHandle and ChildHandle in the form of a Unicode string. If the
    305   driver specified by This has a user-readable name in the language specified by
    306   Language, then a pointer to the controller name is returned in ControllerName,
    307   and EFI_SUCCESS is returned.  If the driver specified by This is not currently
    308   managing the controller specified by ControllerHandle and ChildHandle,
    309   then EFI_UNSUPPORTED is returned.  If the driver specified by This does not
    310   support the language specified by Language, then EFI_UNSUPPORTED is returned.
    311 
    312   @param[in]  This              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
    313                                 EFI_COMPONENT_NAME_PROTOCOL instance.
    314 
    315   @param[in]  ControllerHandle  The handle of a controller that the driver
    316                                 specified by This is managing.  This handle
    317                                 specifies the controller whose name is to be
    318                                 returned.
    319 
    320   @param[in]  ChildHandle       The handle of the child controller to retrieve
    321                                 the name of.  This is an optional parameter that
    322                                 may be NULL.  It will be NULL for device
    323                                 drivers.  It will also be NULL for a bus drivers
    324                                 that wish to retrieve the name of the bus
    325                                 controller.  It will not be NULL for a bus
    326                                 driver that wishes to retrieve the name of a
    327                                 child controller.
    328 
    329   @param[in]  Language          A pointer to a Null-terminated ASCII string
    330                                 array indicating the language.  This is the
    331                                 language of the driver name that the caller is
    332                                 requesting, and it must match one of the
    333                                 languages specified in SupportedLanguages. The
    334                                 number of languages supported by a driver is up
    335                                 to the driver writer. Language is specified in
    336                                 RFC 4646 or ISO 639-2 language code format.
    337 
    338   @param[out]  ControllerName   A pointer to the Unicode string to return.
    339                                 This Unicode string is the name of the
    340                                 controller specified by ControllerHandle and
    341                                 ChildHandle in the language specified by
    342                                 Language from the point of view of the driver
    343                                 specified by This.
    344 
    345   @retval EFI_SUCCESS           The Unicode string for the user-readable name in
    346                                 the language specified by Language for the
    347                                 driver specified by This was returned in
    348                                 DriverName.
    349 
    350   @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
    351 
    352   @retval EFI_INVALID_PARAMETER ChildHandle is not NULL, and it is not a valid
    353                                 EFI_HANDLE.
    354 
    355   @retval EFI_INVALID_PARAMETER Language is NULL.
    356 
    357   @retval EFI_INVALID_PARAMETER ControllerName is NULL.
    358 
    359   @retval EFI_UNSUPPORTED       The driver specified by This is not currently
    360                                 managing the controller specified by
    361                                 ControllerHandle and ChildHandle.
    362 
    363   @retval EFI_UNSUPPORTED       The driver specified by This does not support
    364                                 the language specified by Language.
    365 
    366 **/
    367 EFI_STATUS
    368 EFIAPI
    369 Udp6ComponentNameGetControllerName (
    370   IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
    371   IN  EFI_HANDLE                   ControllerHandle,
    372   IN  EFI_HANDLE                   ChildHandle OPTIONAL,
    373   IN  CHAR8                        *Language,
    374   OUT CHAR16                       **ControllerName
    375   )
    376 {
    377   EFI_STATUS                    Status;
    378   EFI_UDP6_PROTOCOL             *Udp6;
    379 
    380   //
    381   // Only provide names for child handles.
    382   //
    383   if (ChildHandle == NULL) {
    384     return EFI_UNSUPPORTED;
    385   }
    386 
    387   //
    388   // Make sure this driver produced ChildHandle
    389   //
    390   Status = EfiTestChildHandle (
    391              ControllerHandle,
    392              ChildHandle,
    393              &gEfiIp6ProtocolGuid
    394              );
    395   if (EFI_ERROR (Status)) {
    396     return Status;
    397   }
    398 
    399   //
    400   // Retrieve an instance of a produced protocol from ChildHandle
    401   //
    402   Status = gBS->OpenProtocol (
    403                   ChildHandle,
    404                   &gEfiUdp6ProtocolGuid,
    405                   (VOID **)&Udp6,
    406                   NULL,
    407                   NULL,
    408                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
    409                   );
    410   if (EFI_ERROR (Status)) {
    411     return Status;
    412   }
    413 
    414   //
    415   // Update the component name for this child handle.
    416   //
    417   Status = UpdateName (Udp6);
    418   if (EFI_ERROR (Status)) {
    419     return Status;
    420   }
    421 
    422   return LookupUnicodeString2 (
    423            Language,
    424            This->SupportedLanguages,
    425            gUdp6ControllerNameTable,
    426            ControllerName,
    427            (BOOLEAN)(This == &gUdp6ComponentName)
    428            );
    429 }
    430