BaseTools: Remove CYGWIN_NT-5.1-i686 ref from Scripts/PatchCheck.py

[mirror_edk2.git] / RedfishPkg / RedfishRestExDxe / RedfishRestExDriver.h

/** @file\r
  RedfishRestExDxe support functions definitions.\r
\r
  Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>\r
  (C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#ifndef EFI_REDFISH_RESTEX_DRIVER_H_\r
#define EFI_REDFISH_RESTEX_DRIVER_H_\r
\r
///\r
/// Libraries classes\r
///\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/DevicePathLib.h>\r
#include <Library/HttpIoLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/NetLib.h>\r
#include <Library/UefiLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/UefiDriverEntryPoint.h>\r
\r
///\r
/// UEFI Driver Model Protocols\r
///\r
#include <Protocol/DriverBinding.h>\r
#include <Protocol/RestEx.h>\r
#include <Protocol/ServiceBinding.h>\r
\r
///\r
/// Protocol instances\r
///\r
extern EFI_COMPONENT_NAME_PROTOCOL   gRedfishRestExComponentName;\r
extern EFI_COMPONENT_NAME2_PROTOCOL  gRedfishRestExComponentName2;\r
extern EFI_UNICODE_STRING_TABLE      *gRedfishRestExControllerNameTable;\r
\r
extern EFI_DRIVER_BINDING_PROTOCOL   gRedfishRestExDriverBinding;\r
extern EFI_SERVICE_BINDING_PROTOCOL  mRedfishRestExServiceBinding;\r
extern EFI_REST_EX_PROTOCOL          mRedfishRestExProtocol;\r
///\r
/// RestEx service block\r
///\r
typedef struct _RESTEX_SERVICE RESTEX_SERVICE;\r
\r
///\r
/// RestEx instance block\r
///\r
typedef struct _RESTEX_INSTANCE RESTEX_INSTANCE;\r
\r
///\r
/// Driver Version\r
///\r
#define REDFISH_RESTEX_DRIVER_VERSION  0x0100\r
\r
#define RESTEX_SERVICE_SIGNATURE   SIGNATURE_32 ('R', 'E', 'S', 'S')\r
#define RESTEX_INSTANCE_SIGNATURE  SIGNATURE_32 ('R', 'E', 'I', 'S')\r
\r
#define RESTEX_SERVICE_FROM_THIS(a)   \\r
  CR (a, RESTEX_SERVICE, ServiceBinding, RESTEX_SERVICE_SIGNATURE)\r
\r
#define RESTEX_INSTANCE_FROM_THIS(a)  \\r
  CR (a, RESTEX_INSTANCE, RestEx, RESTEX_INSTANCE_SIGNATURE)\r
\r
#define RESTEX_STATE_UNCONFIGED  0\r
#define RESTEX_STATE_CONFIGED    1\r
\r
struct _RESTEX_SERVICE {\r
  UINT32                          Signature;\r
  EFI_SERVICE_BINDING_PROTOCOL    ServiceBinding;\r
\r
  UINT16                          RestExChildrenNum;\r
  LIST_ENTRY                      RestExChildrenList;\r
\r
  EFI_HANDLE                      ControllerHandle;\r
  EFI_HANDLE                      ImageHandle;\r
\r
  //\r
  // Use to establish the parent-child relationship.\r
  //\r
  EFI_HANDLE                      HttpChildHandle;\r
\r
  UINT32                          Id;\r
\r
  EFI_REST_EX_SERVICE_INFO        RestExServiceInfo;\r
};\r
\r
#define RESTEX_INSTANCE_FLAGS_TLS_RETRY        0x00000001\r
#define RESTEX_INSTANCE_FLAGS_TCP_ERROR_RETRY  0x00000002\r
\r
struct _RESTEX_INSTANCE {\r
  UINT32                     Signature;\r
  LIST_ENTRY                 Link;\r
\r
  EFI_REST_EX_PROTOCOL       RestEx;\r
\r
  INTN                       State;\r
  BOOLEAN                    InDestroy;\r
\r
  RESTEX_SERVICE             *Service;\r
  EFI_HANDLE                 ChildHandle;\r
\r
  EFI_REST_EX_CONFIG_DATA    ConfigData;\r
\r
  //\r
  // HTTP_IO to access the HTTP service\r
  //\r
  HTTP_IO                    HttpIo;\r
\r
  UINT32                     Flags;\r
};\r
\r
typedef struct {\r
  EFI_SERVICE_BINDING_PROTOCOL    *ServiceBinding;\r
  UINTN                           NumberOfChildren;\r
  EFI_HANDLE                      *ChildHandleBuffer;\r
} RESTEX_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT;\r
\r
/**\r
  Provides a simple HTTP-like interface to send and receive resources from a REST service.\r
\r
  The SendReceive() function sends an HTTP request to this REST service, and returns a\r
  response when the data is retrieved from the service. RequestMessage contains the HTTP\r
  request to the REST resource identified by RequestMessage.Request.Url. The\r
  ResponseMessage is the returned HTTP response for that request, including any HTTP\r
  status.\r
\r
  @param[in]  This                Pointer to EFI_REST_EX_PROTOCOL instance for a particular\r
                                  REST service.\r
  @param[in]  RequestMessage      Pointer to the HTTP request data for this resource\r
  @param[out] ResponseMessage     Pointer to the HTTP response data obtained for this requested.\r
\r
  @retval EFI_SUCCESS             operation succeeded.\r
  @retval EFI_INVALID_PARAMETER   This, RequestMessage, or ResponseMessage are NULL.\r
  @retval EFI_DEVICE_ERROR        An unexpected system or network error occurred.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExSendReceive (\r
  IN      EFI_REST_EX_PROTOCOL  *This,\r
  IN      EFI_HTTP_MESSAGE      *RequestMessage,\r
  OUT     EFI_HTTP_MESSAGE      *ResponseMessage\r
  );\r
\r
/**\r
  Obtain the current time from this REST service instance.\r
\r
  The GetServiceTime() function is an optional interface to obtain the current time from\r
  this REST service instance. If this REST service does not support to retrieve the time,\r
  this function returns EFI_UNSUPPORTED. This function must returns EFI_UNSUPPORTED if\r
  EFI_REST_EX_SERVICE_TYPE returned in EFI_REST_EX_SERVICE_INFO from GetService() is\r
  EFI_REST_EX_SERVICE_UNSPECIFIC.\r
\r
  @param[in]  This                Pointer to EFI_REST_EX_PROTOCOL instance for a particular\r
                                  REST service.\r
  @param[out] Time                A pointer to storage to receive a snapshot of the current time of\r
                                  the REST service.\r
\r
  @retval EFI_SUCCESS             operation succeeded.\r
  @retval EFI_INVALID_PARAMETER   This or Time are NULL.\r
  @retval EFI_UNSUPPORTED         The RESTful service does not support returning the time.\r
  @retval EFI_DEVICE_ERROR        An unexpected system or network error occurred.\r
  @retval EFI_NOT_READY           The configuration of this instance is not set yet. Configure() must\r
                                  be executed and returns successfully prior to invoke this function.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExGetServiceTime (\r
  IN      EFI_REST_EX_PROTOCOL  *This,\r
  OUT     EFI_TIME              *Time\r
  );\r
\r
/**\r
  This function returns the information of REST service provided by this EFI REST EX driver instance.\r
\r
  The information such as the type of REST service and the access mode of REST EX driver instance\r
  (In-band or Out-of-band) are described in EFI_REST_EX_SERVICE_INFO structure. For the vendor-specific\r
  REST service, vendor-specific REST service information is returned in VendorSpecifcData.\r
  REST EX driver designer is well know what REST service this REST EX driver instance intends to\r
  communicate with. The designer also well know this driver instance is used to talk to BMC through\r
  specific platform mechanism or talk to REST server through UEFI HTTP protocol. REST EX driver is\r
  responsible to fill up the correct information in EFI_REST_EX_SERVICE_INFO. EFI_REST_EX_SERVICE_INFO\r
  is referred by EFI REST clients to pickup the proper EFI REST EX driver instance to get and set resource.\r
  GetService() is a basic and mandatory function which must be able to use even Configure() is not invoked\r
  in previously.\r
\r
  @param[in]  This                Pointer to EFI_REST_EX_PROTOCOL instance for a particular\r
                                  REST service.\r
  @param[out] RestExServiceInfo   Pointer to receive a pointer to EFI_REST_EX_SERVICE_INFO structure. The\r
                                  format of EFI_REST_EX_SERVICE_INFO is version controlled for the future\r
                                  extension. The version of EFI_REST_EX_SERVICE_INFO structure is returned\r
                                  in the header within this structure. EFI REST client refers to the correct\r
                                  format of structure according to the version number. The pointer to\r
                                  EFI_REST_EX_SERVICE_INFO is a memory block allocated by EFI REST EX driver\r
                                  instance. That is caller's responsibility to free this memory when this\r
                                  structure is no longer needed. Refer to Related Definitions below for the\r
                                  definitions of EFI_REST_EX_SERVICE_INFO structure.\r
\r
  @retval EFI_SUCCESS             EFI_REST_EX_SERVICE_INFO is returned in RestExServiceInfo. This function\r
                                  is not supported in this REST EX Protocol driver instance.\r
  @retval EFI_UNSUPPORTED         This function is not supported in this REST EX Protocol driver instance.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExGetService (\r
  IN   EFI_REST_EX_PROTOCOL      *This,\r
  OUT  EFI_REST_EX_SERVICE_INFO  **RestExServiceInfo\r
  );\r
\r
/**\r
  This function returns operational configuration of current EFI REST EX child instance.\r
\r
  This function returns the current configuration of EFI REST EX child instance. The format of\r
  operational configuration depends on the implementation of EFI REST EX driver instance. For\r
  example, HTTP-aware EFI REST EX driver instance uses EFI HTTP protocol as the undying protocol\r
  to communicate with REST service. In this case, the type of configuration is\r
  EFI_REST_EX_CONFIG_TYPE_HTTP returned from GetService(). EFI_HTTP_CONFIG_DATA is used as EFI REST\r
  EX configuration format and returned to EFI REST client. User has to type cast RestExConfigData\r
  to EFI_HTTP_CONFIG_DATA. For those non HTTP-aware REST EX driver instances, the type of configuration\r
  is EFI_REST_EX_CONFIG_TYPE_UNSPECIFIC returned from GetService(). In this case, the format of\r
  returning data could be non industrial. Instead, the format of configuration data is system/platform\r
  specific definition such as BMC mechanism used in EFI REST EX driver instance. EFI REST client and\r
  EFI REST EX driver instance have to refer to the specific system /platform spec which is out of UEFI scope.\r
\r
  @param[in]  This                This is the EFI_REST_EX_PROTOCOL instance.\r
  @param[out] RestExConfigData    Pointer to receive a pointer to EFI_REST_EX_CONFIG_DATA.\r
                                  The memory allocated for configuration data should be freed\r
                                  by caller. See Related Definitions for the details.\r
\r
  @retval EFI_SUCCESS             EFI_REST_EX_CONFIG_DATA is returned in successfully.\r
  @retval EFI_UNSUPPORTED         This function is not supported in this REST EX Protocol driver instance.\r
  @retval EFI_NOT_READY           The configuration of this instance is not set yet. Configure() must be\r
                                  executed and returns successfully prior to invoke this function.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExGetModeData (\r
  IN  EFI_REST_EX_PROTOCOL     *This,\r
  OUT EFI_REST_EX_CONFIG_DATA  *RestExConfigData\r
  );\r
\r
/**\r
  This function is used to configure EFI REST EX child instance.\r
\r
  This function is used to configure the setting of underlying protocol of REST EX child\r
  instance. The type of configuration is according to the implementation of EFI REST EX\r
  driver instance. For example, HTTP-aware EFI REST EX driver instance uses EFI HTTP protocol\r
  as the undying protocol to communicate with REST service. The type of configuration is\r
  EFI_REST_EX_CONFIG_TYPE_HTTP and RestExConfigData is the same format with EFI_HTTP_CONFIG_DATA.\r
  Akin to HTTP configuration, REST EX child instance can be configure to use different HTTP\r
  local access point for the data transmission. Multiple REST clients may use different\r
  configuration of HTTP to distinguish themselves, such as to use the different TCP port.\r
  For those non HTTP-aware REST EX driver instance, the type of configuration is\r
  EFI_REST_EX_CONFIG_TYPE_UNSPECIFIC. RestExConfigData refers to the non industrial standard.\r
  Instead, the format of configuration data is system/platform specific definition such as BMC.\r
  In this case, EFI REST client and EFI REST EX driver instance have to refer to the specific\r
  system/platform spec which is out of the UEFI scope. Besides GetService()function, no other\r
  EFI REST EX functions can be executed by this instance until Configure()is executed and returns\r
  successfully. All other functions must returns EFI_NOT_READY if this instance is not configured\r
  yet. Set RestExConfigData to NULL means to put EFI REST EX child instance into the unconfigured\r
  state.\r
\r
  @param[in]  This                This is the EFI_REST_EX_PROTOCOL instance.\r
  @param[in]  RestExConfigData    Pointer to EFI_REST_EX_CONFIG_DATA. See Related Definitions in\r
                                  GetModeData() protocol interface.\r
\r
  @retval EFI_SUCCESS             EFI_REST_EX_CONFIG_DATA is set in successfully.\r
  @retval EFI_DEVICE_ERROR        Configuration for this REST EX child instance is failed with the given\r
                                  EFI_REST_EX_CONFIG_DATA.\r
  @retval EFI_UNSUPPORTED         This function is not supported in this REST EX Protocol driver instance.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExConfigure (\r
  IN  EFI_REST_EX_PROTOCOL     *This,\r
  IN  EFI_REST_EX_CONFIG_DATA  RestExConfigData\r
  );\r
\r
/**\r
  This function sends REST request to REST service and signal caller's event asynchronously when\r
  the final response is received by REST EX Protocol driver instance.\r
\r
  The essential design of this function is to handle asynchronous send/receive implicitly according\r
  to REST service asynchronous request mechanism. Caller will get the notification once the response\r
  is returned from REST service.\r
\r
  @param[in]  This                  This is the EFI_REST_EX_PROTOCOL instance.\r
  @param[in]  RequestMessage        This is the HTTP request message sent to REST service. Set RequestMessage\r
                                    to NULL to cancel the previous asynchronous request associated with the\r
                                    corresponding RestExToken. See descriptions for the details.\r
  @param[in]  RestExToken           REST EX token which REST EX Protocol instance uses to notify REST client\r
                                    the status of response of asynchronous REST request. See related definition\r
                                    of EFI_REST_EX_TOKEN.\r
  @param[in]  TimeOutInMilliSeconds The pointer to the timeout in milliseconds which REST EX Protocol driver\r
                                    instance refers as the duration to drop asynchronous REST request. NULL\r
                                    pointer means no timeout for this REST request. REST EX Protocol driver\r
                                    signals caller's event with EFI_STATUS set to EFI_TIMEOUT in RestExToken\r
                                    if REST EX Protocol can't get the response from REST service within\r
                                    TimeOutInMilliSeconds.\r
\r
  @retval EFI_SUCCESS               Asynchronous REST request is established.\r
  @retval EFI_UNSUPPORTED           This REST EX Protocol driver instance doesn't support asynchronous request.\r
  @retval EFI_TIMEOUT               Asynchronous REST request is not established and timeout is expired.\r
  @retval EFI_ABORT                 Previous asynchronous REST request has been canceled.\r
  @retval EFI_DEVICE_ERROR          Otherwise, returns EFI_DEVICE_ERROR for other errors according to HTTP Status Code.\r
  @retval EFI_NOT_READY             The configuration of this instance is not set yet. Configure() must be executed\r
                                    and returns successfully prior to invoke this function.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExAyncSendReceive (\r
  IN      EFI_REST_EX_PROTOCOL  *This,\r
  IN      EFI_HTTP_MESSAGE      *RequestMessage OPTIONAL,\r
  IN      EFI_REST_EX_TOKEN     *RestExToken,\r
  IN      UINTN                 *TimeOutInMilliSeconds OPTIONAL\r
  );\r
\r
/**\r
  This function sends REST request to a REST Event service and signals caller's event\r
  token asynchronously when the URI resource change event is received by REST EX\r
  Protocol driver instance.\r
\r
  The essential design of this function is to monitor event implicitly according to\r
  REST service event service mechanism. Caller will get the notification if certain\r
  resource is changed.\r
\r
  @param[in]  This                  This is the EFI_REST_EX_PROTOCOL instance.\r
  @param[in]  RequestMessage        This is the HTTP request message sent to REST service. Set RequestMessage\r
                                    to NULL to cancel the previous event service associated with the corresponding\r
                                    RestExToken. See descriptions for the details.\r
  @param[in]  RestExToken           REST EX token which REST EX Protocol driver instance uses to notify REST client\r
                                    the URI resource which monitored by REST client has been changed. See the related\r
                                    definition of EFI_REST_EX_TOKEN in EFI_REST_EX_PROTOCOL.AsyncSendReceive().\r
\r
  @retval EFI_SUCCESS               Asynchronous REST request is established.\r
  @retval EFI_UNSUPPORTED           This REST EX Protocol driver instance doesn't support asynchronous request.\r
  @retval EFI_ABORT                 Previous asynchronous REST request has been canceled or event subscription has been\r
                                    delete from service.\r
  @retval EFI_DEVICE_ERROR          Otherwise, returns EFI_DEVICE_ERROR for other errors according to HTTP Status Code.\r
  @retval EFI_NOT_READY             The configuration of this instance is not set yet. Configure() must be executed\r
                                    and returns successfully prior to invoke this function.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExEventService (\r
  IN      EFI_REST_EX_PROTOCOL  *This,\r
  IN      EFI_HTTP_MESSAGE      *RequestMessage OPTIONAL,\r
  IN      EFI_REST_EX_TOKEN     *RestExToken\r
  );\r
\r
/**\r
  Create a new TLS session becuase the previous on is closed.\r
  status.\r
\r
  @param[in]  Instance            Pointer to EFI_REST_EX_PROTOCOL instance for a particular\r
                                  REST service.\r
  @retval EFI_SUCCESS             operation succeeded.\r
  @retval EFI Errors              Other errors.\r
\r
**/\r
EFI_STATUS\r
ResetHttpTslSession (\r
  IN   RESTEX_INSTANCE  *Instance\r
  );\r
\r
/**\r
  Callback function which provided by user to remove one node in NetDestroyLinkList process.\r
\r
  @param[in]    Entry           The entry to be removed.\r
  @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.\r
\r
  @retval EFI_SUCCESS           The entry has been removed successfully.\r
  @retval Others                Fail to remove the entry.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RestExDestroyChildEntryInHandleBuffer (\r
  IN LIST_ENTRY  *Entry,\r
  IN VOID        *Context\r
  );\r
\r
/**\r
  Destroy the RestEx instance and recycle the resources.\r
\r
  @param[in]  Instance        The pointer to the RestEx instance.\r
\r
**/\r
VOID\r
RestExDestroyInstance (\r
  IN RESTEX_INSTANCE  *Instance\r
  );\r
\r
/**\r
  Create the RestEx instance and initialize it.\r
\r
  @param[in]  Service              The pointer to the RestEx service.\r
  @param[out] Instance             The pointer to the RestEx instance.\r
\r
  @retval EFI_OUT_OF_RESOURCES   Failed to allocate resources.\r
  @retval EFI_SUCCESS            The RestEx instance is created.\r
\r
**/\r
EFI_STATUS\r
RestExCreateInstance (\r
  IN  RESTEX_SERVICE   *Service,\r
  OUT RESTEX_INSTANCE  **Instance\r
  );\r
\r
/**\r
  Release all the resource used the RestEx service binding instance.\r
\r
  @param  RestExSb                The RestEx service binding instance.\r
\r
**/\r
VOID\r
RestExDestroyService (\r
  IN RESTEX_SERVICE  *RestExSb\r
  );\r
\r
/**\r
  Create then initialize a RestEx service binding instance.\r
\r
  @param[in]   Controller       The controller to install the RestEx service\r
                                binding on.\r
  @param[in]   Image            The driver binding image of the RestEx driver.\r
  @param[out]  Service          The variable to receive the created service\r
                                binding instance.\r
\r
  @retval EFI_OUT_OF_RESOURCES   Failed to allocate resource to create the instance.\r
  @retval EFI_SUCCESS            The service instance is created for the controller.\r
\r
**/\r
EFI_STATUS\r
RestExCreateService (\r
  IN     EFI_HANDLE      Controller,\r
  IN     EFI_HANDLE      Image,\r
  OUT    RESTEX_SERVICE  **Service\r
  );\r
\r
/**\r
  This is the declaration of an EFI image entry point. This entry point is\r
  the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including\r
  both device drivers and bus drivers.\r
\r
  @param[in]   ImageHandle     The firmware allocated handle for the UEFI image.\r
  @param[in]   SystemTable     A pointer to the EFI System Table.\r
\r
  @retval EFI_SUCCESS           The operation completed successfully.\r
  @retval Others                An unexpected error occurred.\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExDriverEntryPoint (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  );\r
\r
/**\r
  Tests to see if this driver supports a given controller. If a child device is provided,\r
  it further tests to see if this driver supports creating a handle for the specified child device.\r
\r
  This function checks to see if the driver specified by This supports the device specified by\r
  ControllerHandle. Drivers will typically use the device path attached to\r
  ControllerHandle and/or the services from the bus I/O abstraction attached to\r
  ControllerHandle to determine if the driver supports ControllerHandle. This function\r
  may be called many times during platform initialization. In order to reduce boot times, the tests\r
  performed by this function must be very small, and take as little time as possible to execute. This\r
  function must not change the state of any hardware devices, and this function must be aware that the\r
  device specified by ControllerHandle may already be managed by the same driver or a\r
  different driver. This function must match its calls to AllocatePages() with FreePages(),\r
  AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().\r
  Because ControllerHandle may have been previously started by the same driver, if a protocol is\r
  already in the opened state, then it must not be closed with CloseProtocol(). This is required\r
  to guarantee the state of ControllerHandle is not modified by this function.\r
\r
  @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.\r
  @param[in]  ControllerHandle     The handle of the controller to test. This handle\r
                                   must support a protocol interface that supplies\r
                                   an I/O abstraction to the driver.\r
  @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This\r
                                   parameter is ignored by device drivers, and is optional for bus\r
                                   drivers. For bus drivers, if this parameter is not NULL, then\r
                                   the bus driver must determine if the bus controller specified\r
                                   by ControllerHandle and the child controller specified\r
                                   by RemainingDevicePath are both supported by this\r
                                   bus driver.\r
\r
  @retval EFI_SUCCESS              The device specified by ControllerHandle and\r
                                   RemainingDevicePath is supported by the driver specified by This.\r
  @retval EFI_ALREADY_STARTED      The device specified by ControllerHandle and\r
                                   RemainingDevicePath is already being managed by the driver\r
                                   specified by This.\r
  @retval EFI_ACCESS_DENIED        The device specified by ControllerHandle and\r
                                   RemainingDevicePath is already being managed by a different\r
                                   driver or an application that requires exclusive access.\r
                                   Currently not implemented.\r
  @retval EFI_UNSUPPORTED          The device specified by ControllerHandle and\r
                                   RemainingDevicePath is not supported by the driver specified by This.\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExDriverBindingSupported (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   ControllerHandle,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL\r
  );\r
\r
/**\r
  Starts a device controller or a bus controller.\r
\r
  The Start() function is designed to be invoked from the EFI boot service ConnectController().\r
  As a result, much of the error checking on the parameters to Start() has been moved into this\r
  common boot service. It is legal to call Start() from other locations,\r
  but the following calling restrictions must be followed, or the system behavior will not be deterministic.\r
  1. ControllerHandle must be a valid EFI_HANDLE.\r
  2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned\r
     EFI_DEVICE_PATH_PROTOCOL.\r
  3. Prior to calling Start(), the Supported() function for the driver specified by This must\r
     have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.\r
\r
  @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.\r
  @param[in]  ControllerHandle     The handle of the controller to start. This handle\r
                                   must support a protocol interface that supplies\r
                                   an I/O abstraction to the driver.\r
  @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This\r
                                   parameter is ignored by device drivers, and is optional for bus\r
                                   drivers. For a bus driver, if this parameter is NULL, then handles\r
                                   for all the children of Controller are created by this driver.\r
                                   If this parameter is not NULL and the first Device Path Node is\r
                                   not the End of Device Path Node, then only the handle for the\r
                                   child device specified by the first Device Path Node of\r
                                   RemainingDevicePath is created by this driver.\r
                                   If the first Device Path Node of RemainingDevicePath is\r
                                   the End of Device Path Node, no child handle is created by this\r
                                   driver.\r
\r
  @retval EFI_SUCCESS              The device was started.\r
  @retval EFI_DEVICE_ERROR         The device could not be started due to a device error.Currently not implemented.\r
  @retval EFI_OUT_OF_RESOURCES     The request could not be completed due to a lack of resources.\r
  @retval Others                   The driver failded to start the device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExDriverBindingStart (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   ControllerHandle,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL\r
  );\r
\r
/**\r
  Stops a device controller or a bus controller.\r
\r
  The Stop() function is designed to be invoked from the EFI boot service DisconnectController().\r
  As a result, much of the error checking on the parameters to Stop() has been moved\r
  into this common boot service. It is legal to call Stop() from other locations,\r
  but the following calling restrictions must be followed, or the system behavior will not be deterministic.\r
  1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this\r
     same driver's Start() function.\r
  2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid\r
     EFI_HANDLE. In addition, all of these handles must have been created in this driver's\r
     Start() function, and the Start() function must have called OpenProtocol() on\r
     ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.\r
\r
  @param[in]  This              A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.\r
  @param[in]  ControllerHandle  A handle to the device being stopped. The handle must\r
                                support a bus specific I/O protocol for the driver\r
                                to use to stop the device.\r
  @param[in]  NumberOfChildren  The number of child device handles in ChildHandleBuffer.\r
  @param[in]  ChildHandleBuffer An array of child handles to be freed. May be NULL\r
                                if NumberOfChildren is 0.\r
\r
  @retval EFI_SUCCESS           The device was stopped.\r
  @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device error.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExDriverBindingStop (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   ControllerHandle,\r
  IN UINTN                        NumberOfChildren,\r
  IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL\r
  );\r
\r
/**\r
  Creates a child handle and installs a protocol.\r
\r
  The CreateChild() function installs a protocol on ChildHandle.\r
  If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.\r
  If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.\r
\r
  @param[in] This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.\r
  @param[in] ChildHandle Pointer to the handle of the child to create. If it is NULL,\r
                         then a new handle is created. If it is a pointer to an existing UEFI handle,\r
                         then the protocol is added to the existing UEFI handle.\r
\r
  @retval EFI_SUCCES            The protocol was added to ChildHandle.\r
  @retval EFI_INVALID_PARAMETER ChildHandle is NULL.\r
  @retval EFI_OUT_OF_RESOURCES  There are not enough resources available to create\r
                                the child\r
  @retval other                 The child handle was not created\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExServiceBindingCreateChild (\r
  IN EFI_SERVICE_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                    *ChildHandle\r
  );\r
\r
/**\r
  Destroys a child handle with a protocol installed on it.\r
\r
  The DestroyChild() function does the opposite of CreateChild(). It removes a protocol\r
  that was installed by CreateChild() from ChildHandle. If the removed protocol is the\r
  last protocol on ChildHandle, then ChildHandle is destroyed.\r
\r
  @param[in] This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.\r
  @param[in] ChildHandle Handle of the child to destroy\r
\r
  @retval EFI_SUCCES            The protocol was removed from ChildHandle.\r
  @retval EFI_UNSUPPORTED       ChildHandle does not support the protocol that is being removed.\r
  @retval EFI_INVALID_PARAMETER Child handle is NULL.\r
  @retval EFI_ACCESS_DENIED     The protocol could not be removed from the ChildHandle\r
                                because its services are being used.\r
  @retval other                 The child handle was not destroyed\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RedfishRestExServiceBindingDestroyChild (\r
  IN EFI_SERVICE_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                    ChildHandle\r
  );\r
\r
#endif\r