| /** @file | |
| This file implements I2C IO Protocol which enables the user to manipulate a single | |
| I2C device independent of the host controller and I2C design. | |
| Copyright (c) 2013 - 2018, Intel Corporation. All rights reserved.<BR> | |
| SPDX-License-Identifier: BSD-2-Clause-Patent | |
| **/ | |
| #include "I2cDxe.h" | |
| // | |
| // EFI_DRIVER_BINDING_PROTOCOL instance | |
| // | |
| EFI_DRIVER_BINDING_PROTOCOL gI2cBusDriverBinding = { | |
| I2cBusDriverSupported, | |
| I2cBusDriverStart, | |
| I2cBusDriverStop, | |
| 0x10, | |
| NULL, | |
| NULL | |
| }; | |
| // | |
| // Template for I2C Bus Child Device. | |
| // | |
| I2C_DEVICE_CONTEXT gI2cDeviceContextTemplate = { | |
| I2C_DEVICE_SIGNATURE, | |
| NULL, | |
| { // I2cIo Protocol | |
| I2cBusQueueRequest, // QueueRequest | |
| NULL, // DeviceGuid | |
| 0, // DeviceIndex | |
| 0, // HardwareRevision | |
| NULL // I2cControllerCapabilities | |
| }, | |
| NULL, // DevicePath | |
| NULL, // I2cDevice | |
| NULL, // I2cBusContext | |
| }; | |
| // | |
| // Template for controller device path node. | |
| // | |
| CONTROLLER_DEVICE_PATH gControllerDevicePathTemplate = { | |
| { | |
| HARDWARE_DEVICE_PATH, | |
| HW_CONTROLLER_DP, | |
| { | |
| (UINT8)(sizeof (CONTROLLER_DEVICE_PATH)), | |
| (UINT8)((sizeof (CONTROLLER_DEVICE_PATH)) >> 8) | |
| } | |
| }, | |
| 0 | |
| }; | |
| // | |
| // Template for vendor device path node. | |
| // | |
| VENDOR_DEVICE_PATH gVendorDevicePathTemplate = { | |
| { | |
| HARDWARE_DEVICE_PATH, | |
| HW_VENDOR_DP, | |
| { | |
| (UINT8)(sizeof (VENDOR_DEVICE_PATH)), | |
| (UINT8)((sizeof (VENDOR_DEVICE_PATH)) >> 8) | |
| } | |
| }, | |
| { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } | |
| } | |
| }; | |
| // | |
| // Driver name table | |
| // | |
| GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mI2cBusDriverNameTable[] = { | |
| { "eng;en", (CHAR16 *)L"I2C Bus Driver" }, | |
| { NULL, NULL } | |
| }; | |
| // | |
| // EFI Component Name Protocol | |
| // | |
| GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL gI2cBusComponentName = { | |
| (EFI_COMPONENT_NAME_GET_DRIVER_NAME)I2cBusComponentNameGetDriverName, | |
| (EFI_COMPONENT_NAME_GET_CONTROLLER_NAME)I2cBusComponentNameGetControllerName, | |
| "eng" | |
| }; | |
| // | |
| // EFI Component Name 2 Protocol | |
| // | |
| GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gI2cBusComponentName2 = { | |
| I2cBusComponentNameGetDriverName, | |
| I2cBusComponentNameGetControllerName, | |
| "en" | |
| }; | |
| /** | |
| Retrieves a Unicode string that is the user readable name of the driver. | |
| This function retrieves the user readable name of a driver in the form of a | |
| Unicode string. If the driver specified by This has a user readable name in | |
| the language specified by Language, then a pointer to the driver name is | |
| returned in DriverName, and EFI_SUCCESS is returned. If the driver specified | |
| by This does not support the language specified by Language, | |
| then EFI_UNSUPPORTED is returned. | |
| @param This[in] A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or | |
| EFI_COMPONENT_NAME_PROTOCOL instance. | |
| @param Language[in] A pointer to a Null-terminated ASCII string | |
| array indicating the language. This is the | |
| language of the driver name that the caller is | |
| requesting, and it must match one of the | |
| languages specified in SupportedLanguages. The | |
| number of languages supported by a driver is up | |
| to the driver writer. Language is specified | |
| in RFC 4646 or ISO 639-2 language code format. | |
| @param DriverName[out] A pointer to the Unicode string to return. | |
| This Unicode string is the name of the | |
| driver specified by This in the language | |
| specified by Language. | |
| @retval EFI_SUCCESS The Unicode string for the Driver specified by | |
| This and the language specified by Language was | |
| returned in DriverName. | |
| @retval EFI_INVALID_PARAMETER Language is NULL. | |
| @retval EFI_INVALID_PARAMETER DriverName is NULL. | |
| @retval EFI_UNSUPPORTED The driver specified by This does not support | |
| the language specified by Language. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| I2cBusComponentNameGetDriverName ( | |
| IN EFI_COMPONENT_NAME2_PROTOCOL *This, | |
| IN CHAR8 *Language, | |
| OUT CHAR16 **DriverName | |
| ) | |
| { | |
| return LookupUnicodeString2 ( | |
| Language, | |
| This->SupportedLanguages, | |
| mI2cBusDriverNameTable, | |
| DriverName, | |
| (BOOLEAN)(This != &gI2cBusComponentName2) | |
| ); | |
| } | |
| /** | |
| Retrieves a Unicode string that is the user readable name of the controller | |
| that is being managed by a driver. | |
| This function retrieves the user readable name of the controller specified by | |
| ControllerHandle and ChildHandle in the form of a Unicode string. If the | |
| driver specified by This has a user readable name in the language specified by | |
| Language, then a pointer to the controller name is returned in ControllerName, | |
| and EFI_SUCCESS is returned. If the driver specified by This is not currently | |
| managing the controller specified by ControllerHandle and ChildHandle, | |
| then EFI_UNSUPPORTED is returned. If the driver specified by This does not | |
| support the language specified by Language, then EFI_UNSUPPORTED is returned. | |
| @param This[in] A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or | |
| EFI_COMPONENT_NAME_PROTOCOL instance. | |
| @param ControllerHandle[in] The handle of a controller that the driver | |
| specified by This is managing. This handle | |
| specifies the controller whose name is to be | |
| returned. | |
| @param ChildHandle[in] The handle of the child controller to retrieve | |
| the name of. This is an optional parameter that | |
| may be NULL. It will be NULL for device | |
| drivers. It will also be NULL for a bus drivers | |
| that wish to retrieve the name of the bus | |
| controller. It will not be NULL for a bus | |
| driver that wishes to retrieve the name of a | |
| child controller. | |
| @param Language[in] A pointer to a Null-terminated ASCII string | |
| array indicating the language. This is the | |
| language of the driver name that the caller is | |
| requesting, and it must match one of the | |
| languages specified in SupportedLanguages. The | |
| number of languages supported by a driver is up | |
| to the driver writer. Language is specified in | |
| RFC 4646 or ISO 639-2 language code format. | |
| @param ControllerName[out] A pointer to the Unicode string to return. | |
| This Unicode string is the name of the | |
| controller specified by ControllerHandle and | |
| ChildHandle in the language specified by | |
| Language from the point of view of the driver | |
| specified by This. | |
| @retval EFI_SUCCESS The Unicode string for the user readable name in | |
| the language specified by Language for the | |
| driver specified by This was returned in | |
| DriverName. | |
| @retval EFI_INVALID_PARAMETER ControllerHandle is NULL. | |
| @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid | |
| EFI_HANDLE. | |
| @retval EFI_INVALID_PARAMETER Language is NULL. | |
| @retval EFI_INVALID_PARAMETER ControllerName is NULL. | |
| @retval EFI_UNSUPPORTED The driver specified by This is not currently | |
| managing the controller specified by | |
| ControllerHandle and ChildHandle. | |
| @retval EFI_UNSUPPORTED The driver specified by This does not support | |
| the language specified by Language. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| I2cBusComponentNameGetControllerName ( | |
| IN EFI_COMPONENT_NAME2_PROTOCOL *This, | |
| IN EFI_HANDLE ControllerHandle, | |
| IN EFI_HANDLE ChildHandle OPTIONAL, | |
| IN CHAR8 *Language, | |
| OUT CHAR16 **ControllerName | |
| ) | |
| { | |
| return EFI_UNSUPPORTED; | |
| } | |
| /** | |
| Check if the child of I2C controller has been created. | |
| @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. | |
| @param[in] Controller I2C controller handle. | |
| @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. | |
| @param[in] RemainingHasControllerNode Indicate if RemainingDevicePath contains CONTROLLER_DEVICE_PATH. | |
| @param[in] RemainingControllerNumber Controller number in CONTROLLER_DEVICE_PATH. | |
| @retval EFI_SUCCESS The child of I2C controller is not created. | |
| @retval Others The child of I2C controller has been created or other errors happen. | |
| **/ | |
| EFI_STATUS | |
| CheckRemainingDevicePath ( | |
| IN EFI_DRIVER_BINDING_PROTOCOL *This, | |
| IN EFI_HANDLE Controller, | |
| IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath, | |
| IN BOOLEAN RemainingHasControllerNode, | |
| IN UINT32 RemainingControllerNumber | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_DEVICE_PATH_PROTOCOL *SystemDevicePath; | |
| EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfoBuffer; | |
| UINTN EntryCount; | |
| UINTN Index; | |
| BOOLEAN SystemHasControllerNode; | |
| UINT32 SystemControllerNumber; | |
| SystemHasControllerNode = FALSE; | |
| SystemControllerNumber = 0; | |
| Status = gBS->OpenProtocolInformation ( | |
| Controller, | |
| &gEfiI2cHostProtocolGuid, | |
| &OpenInfoBuffer, | |
| &EntryCount | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| for (Index = 0; Index < EntryCount; Index++) { | |
| if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) { | |
| Status = gBS->OpenProtocol ( | |
| OpenInfoBuffer[Index].ControllerHandle, | |
| &gEfiDevicePathProtocolGuid, | |
| (VOID **)&SystemDevicePath, | |
| This->DriverBindingHandle, | |
| Controller, | |
| EFI_OPEN_PROTOCOL_GET_PROTOCOL | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| // | |
| // Find vendor device path node and compare | |
| // | |
| while (!IsDevicePathEnd (SystemDevicePath)) { | |
| if ((DevicePathType (SystemDevicePath) == HARDWARE_DEVICE_PATH) && | |
| (DevicePathSubType (SystemDevicePath) == HW_VENDOR_DP)) | |
| { | |
| // | |
| // Check if vendor device path is same between system device path and remaining device path | |
| // | |
| if (CompareMem (SystemDevicePath, RemainingDevicePath, sizeof (VENDOR_DEVICE_PATH)) == 0) { | |
| // | |
| // Get controller node appended after vendor node | |
| // | |
| SystemDevicePath = NextDevicePathNode (SystemDevicePath); | |
| if ((DevicePathType (SystemDevicePath) == HARDWARE_DEVICE_PATH) && | |
| (DevicePathSubType (SystemDevicePath) == HW_CONTROLLER_DP)) | |
| { | |
| SystemHasControllerNode = TRUE; | |
| SystemControllerNumber = ((CONTROLLER_DEVICE_PATH *)SystemDevicePath)->ControllerNumber; | |
| } else { | |
| SystemHasControllerNode = FALSE; | |
| SystemControllerNumber = 0; | |
| } | |
| if (((SystemHasControllerNode) && (!RemainingHasControllerNode) && (SystemControllerNumber == 0)) || | |
| ((!SystemHasControllerNode) && (RemainingHasControllerNode) && (RemainingControllerNumber == 0)) || | |
| ((SystemHasControllerNode) && (RemainingHasControllerNode) && (SystemControllerNumber == RemainingControllerNumber)) || | |
| ((!SystemHasControllerNode) && (!RemainingHasControllerNode))) | |
| { | |
| DEBUG ((DEBUG_ERROR, "This I2C device has been already started.\n")); | |
| Status = EFI_UNSUPPORTED; | |
| break; | |
| } | |
| } | |
| } | |
| SystemDevicePath = NextDevicePathNode (SystemDevicePath); | |
| } | |
| if (EFI_ERROR (Status)) { | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| FreePool (OpenInfoBuffer); | |
| return Status; | |
| } | |
| /** | |
| Tests to see if this driver supports a given controller. If a child device is provided, | |
| it further tests to see if this driver supports creating a handle for the specified child device. | |
| This function checks to see if the driver specified by This supports the device specified by | |
| ControllerHandle. Drivers will typically use the device path attached to | |
| ControllerHandle and/or the services from the bus I/O abstraction attached to | |
| ControllerHandle to determine if the driver supports ControllerHandle. This function | |
| may be called many times during platform initialization. In order to reduce boot times, the tests | |
| performed by this function must be very small, and take as little time as possible to execute. This | |
| function must not change the state of any hardware devices, and this function must be aware that the | |
| device specified by ControllerHandle may already be managed by the same driver or a | |
| different driver. This function must match its calls to AllocatePages() with FreePages(), | |
| AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol(). | |
| Since ControllerHandle may have been previously started by the same driver, if a protocol is | |
| already in the opened state, then it must not be closed with CloseProtocol(). This is required | |
| to guarantee the state of ControllerHandle is not modified by this function. | |
| @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. | |
| @param[in] ControllerHandle The handle of the controller to test. This handle | |
| must support a protocol interface that supplies | |
| an I/O abstraction to the driver. | |
| @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This | |
| parameter is ignored by device drivers, and is optional for bus | |
| drivers. For bus drivers, if this parameter is not NULL, then | |
| the bus driver must determine if the bus controller specified | |
| by ControllerHandle and the child controller specified | |
| by RemainingDevicePath are both supported by this | |
| bus driver. | |
| @retval EFI_SUCCESS The device specified by ControllerHandle and | |
| RemainingDevicePath is supported by the driver specified by This. | |
| @retval EFI_ALREADY_STARTED The device specified by ControllerHandle and | |
| RemainingDevicePath is already being managed by the driver | |
| specified by This. | |
| @retval EFI_ACCESS_DENIED The device specified by ControllerHandle and | |
| RemainingDevicePath is already being managed by a different | |
| driver or an application that requires exclusive access. | |
| Currently not implemented. | |
| @retval EFI_UNSUPPORTED The device specified by ControllerHandle and | |
| RemainingDevicePath is not supported by the driver specified by This. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| I2cBusDriverSupported ( | |
| IN EFI_DRIVER_BINDING_PROTOCOL *This, | |
| IN EFI_HANDLE Controller, | |
| IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_I2C_ENUMERATE_PROTOCOL *I2cEnumerate; | |
| EFI_I2C_HOST_PROTOCOL *I2cHost; | |
| EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; | |
| EFI_DEVICE_PATH_PROTOCOL *DevPathNode; | |
| BOOLEAN RemainingHasControllerNode; | |
| UINT32 RemainingControllerNumber; | |
| RemainingHasControllerNode = FALSE; | |
| RemainingControllerNumber = 0; | |
| // | |
| // Determine if the I2c Enumerate Protocol is available | |
| // | |
| Status = gBS->OpenProtocol ( | |
| Controller, | |
| &gEfiI2cEnumerateProtocolGuid, | |
| (VOID **)&I2cEnumerate, | |
| This->DriverBindingHandle, | |
| Controller, | |
| EFI_OPEN_PROTOCOL_BY_DRIVER | |
| ); | |
| if ((EFI_ERROR (Status)) && (Status != EFI_ALREADY_STARTED)) { | |
| return Status; | |
| } | |
| if (!EFI_ERROR (Status)) { | |
| gBS->CloseProtocol ( | |
| Controller, | |
| &gEfiI2cEnumerateProtocolGuid, | |
| This->DriverBindingHandle, | |
| Controller | |
| ); | |
| } | |
| Status = gBS->OpenProtocol ( | |
| Controller, | |
| &gEfiDevicePathProtocolGuid, | |
| (VOID **)&ParentDevicePath, | |
| This->DriverBindingHandle, | |
| Controller, | |
| EFI_OPEN_PROTOCOL_BY_DRIVER | |
| ); | |
| if ((EFI_ERROR (Status)) && (Status != EFI_ALREADY_STARTED)) { | |
| return Status; | |
| } | |
| if (!EFI_ERROR (Status)) { | |
| gBS->CloseProtocol ( | |
| Controller, | |
| &gEfiDevicePathProtocolGuid, | |
| This->DriverBindingHandle, | |
| Controller | |
| ); | |
| } | |
| if ((RemainingDevicePath != NULL) && !IsDevicePathEnd (RemainingDevicePath)) { | |
| // | |
| // Check if the first node of RemainingDevicePath is a hardware vendor device path | |
| // | |
| if ((DevicePathType (RemainingDevicePath) != HARDWARE_DEVICE_PATH) || | |
| (DevicePathSubType (RemainingDevicePath) != HW_VENDOR_DP)) | |
| { | |
| return EFI_UNSUPPORTED; | |
| } | |
| // | |
| // Check if the second node of RemainingDevicePath is a controller node | |
| // | |
| DevPathNode = NextDevicePathNode (RemainingDevicePath); | |
| if (!IsDevicePathEnd (DevPathNode)) { | |
| if ((DevicePathType (DevPathNode) != HARDWARE_DEVICE_PATH) || | |
| (DevicePathSubType (DevPathNode) != HW_CONTROLLER_DP)) | |
| { | |
| return EFI_UNSUPPORTED; | |
| } else { | |
| RemainingHasControllerNode = TRUE; | |
| RemainingControllerNumber = ((CONTROLLER_DEVICE_PATH *)DevPathNode)->ControllerNumber; | |
| } | |
| } | |
| } | |
| // | |
| // Determine if the I2C Host Protocol is available | |
| // | |
| Status = gBS->OpenProtocol ( | |
| Controller, | |
| &gEfiI2cHostProtocolGuid, | |
| (VOID **)&I2cHost, | |
| This->DriverBindingHandle, | |
| Controller, | |
| EFI_OPEN_PROTOCOL_BY_DRIVER | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| gBS->CloseProtocol ( | |
| Controller, | |
| &gEfiI2cHostProtocolGuid, | |
| This->DriverBindingHandle, | |
| Controller | |
| ); | |
| } | |
| if (Status == EFI_ALREADY_STARTED) { | |
| if ((RemainingDevicePath == NULL) || | |
| ((RemainingDevicePath != NULL) && IsDevicePathEnd (RemainingDevicePath))) | |
| { | |
| // | |
| // If RemainingDevicePath is NULL or is the End of Device Path Node, return EFI_SUCCESS. | |
| // | |
| Status = EFI_SUCCESS; | |
| } else { | |
| // | |
| // Test if the child with the RemainingDevicePath has already been created. | |
| // | |
| Status = CheckRemainingDevicePath ( | |
| This, | |
| Controller, | |
| RemainingDevicePath, | |
| RemainingHasControllerNode, | |
| RemainingControllerNumber | |
| ); | |
| } | |
| } | |
| return Status; | |
| } | |
| /** | |
| Starts a device controller or a bus controller. | |
| The Start() function is designed to be invoked from the EFI boot service ConnectController(). | |
| As a result, much of the error checking on the parameters to Start() has been moved into this | |
| common boot service. It is legal to call Start() from other locations, | |
| but the following calling restrictions must be followed or the system behavior will not be deterministic. | |
| 1. ControllerHandle must be a valid EFI_HANDLE. | |
| 2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned | |
| EFI_DEVICE_PATH_PROTOCOL. | |
| 3. Prior to calling Start(), the Supported() function for the driver specified by This must | |
| have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS. | |
| @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. | |
| @param[in] ControllerHandle The handle of the controller to start. This handle | |
| must support a protocol interface that supplies | |
| an I/O abstraction to the driver. | |
| @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This | |
| parameter is ignored by device drivers, and is optional for bus | |
| drivers. For a bus driver, if this parameter is NULL, then handles | |
| for all the children of Controller are created by this driver. | |
| If this parameter is not NULL and the first Device Path Node is | |
| not the End of Device Path Node, then only the handle for the | |
| child device specified by the first Device Path Node of | |
| RemainingDevicePath is created by this driver. | |
| If the first Device Path Node of RemainingDevicePath is | |
| the End of Device Path Node, no child handle is created by this | |
| driver. | |
| @retval EFI_SUCCESS The device was started. | |
| @retval EFI_DEVICE_ERROR The device could not be started due to a device error.Currently not implemented. | |
| @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. | |
| @retval Others The driver failed to start the device. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| I2cBusDriverStart ( | |
| IN EFI_DRIVER_BINDING_PROTOCOL *This, | |
| IN EFI_HANDLE Controller, | |
| IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath | |
| ) | |
| { | |
| EFI_I2C_ENUMERATE_PROTOCOL *I2cEnumerate; | |
| EFI_I2C_HOST_PROTOCOL *I2cHost; | |
| I2C_BUS_CONTEXT *I2cBusContext; | |
| EFI_STATUS Status; | |
| EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; | |
| I2cBusContext = NULL; | |
| ParentDevicePath = NULL; | |
| I2cEnumerate = NULL; | |
| I2cHost = NULL; | |
| // | |
| // Determine if the I2C controller is available | |
| // | |
| Status = gBS->OpenProtocol ( | |
| Controller, | |
| &gEfiI2cHostProtocolGuid, | |
| (VOID **)&I2cHost, | |
| This->DriverBindingHandle, | |
| Controller, | |
| EFI_OPEN_PROTOCOL_BY_DRIVER | |
| ); | |
| if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) { | |
| DEBUG ((DEBUG_ERROR, "I2cBus: open I2C host error, Status = %r\n", Status)); | |
| return Status; | |
| } | |
| if (Status == EFI_ALREADY_STARTED) { | |
| Status = gBS->OpenProtocol ( | |
| Controller, | |
| &gEfiCallerIdGuid, | |
| (VOID **)&I2cBusContext, | |
| This->DriverBindingHandle, | |
| Controller, | |
| EFI_OPEN_PROTOCOL_GET_PROTOCOL | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG ((DEBUG_ERROR, "I2cBus: open private protocol error, Status = %r.\n", Status)); | |
| return Status; | |
| } | |
| } | |
| // | |
| // Get the I2C bus enumeration API | |
| // | |
| Status = gBS->OpenProtocol ( | |
| Controller, | |
| &gEfiI2cEnumerateProtocolGuid, | |
| (VOID **)&I2cEnumerate, | |
| This->DriverBindingHandle, | |
| Controller, | |
| EFI_OPEN_PROTOCOL_BY_DRIVER | |
| ); | |
| if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) { | |
| DEBUG ((DEBUG_ERROR, "I2cBus: open I2C enumerate error, Status = %r\n", Status)); | |
| goto Error; | |
| } | |
| Status = gBS->OpenProtocol ( | |
| Controller, | |
| &gEfiDevicePathProtocolGuid, | |
| (VOID **)&ParentDevicePath, | |
| This->DriverBindingHandle, | |
| Controller, | |
| EFI_OPEN_PROTOCOL_BY_DRIVER | |
| ); | |
| if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) { | |
| DEBUG ((DEBUG_ERROR, "I2cBus: open device path error, Status = %r\n", Status)); | |
| goto Error; | |
| } | |
| if ((RemainingDevicePath != NULL) && IsDevicePathEnd (RemainingDevicePath)) { | |
| // | |
| // If RemainingDevicePath is the End of Device Path Node, | |
| // don't create any child device and return EFI_SUCCESS | |
| // | |
| return EFI_SUCCESS; | |
| } | |
| // | |
| // Allocate the buffer for I2C_BUS_CONTEXT if it is not allocated before. | |
| // | |
| if (I2cBusContext == NULL) { | |
| // | |
| // Allocate the I2C context structure for the current I2C controller | |
| // | |
| I2cBusContext = AllocateZeroPool (sizeof (I2C_BUS_CONTEXT)); | |
| if (I2cBusContext == NULL) { | |
| DEBUG ((DEBUG_ERROR, "I2cBus: there is no enough memory to allocate.\n")); | |
| Status = EFI_OUT_OF_RESOURCES; | |
| goto Error; | |
| } | |
| /* | |
| +----------------+ | |
| .->| I2C_BUS_CONTEXT|<----- This file Protocol (gEfiCallerIdGuid) installed on I2C Controller handle | |
| | +----------------+ | |
| | | |
| | +----------------------------+ | |
| | | I2C_DEVICE_CONTEXT | | |
| `--| | | |
| | | | |
| | I2C IO Protocol Structure | <----- I2C IO Protocol | |
| | | | |
| +----------------------------+ | |
| */ | |
| I2cBusContext->I2cHost = I2cHost; | |
| I2cBusContext->I2cEnumerate = I2cEnumerate; | |
| // | |
| // Parent controller used to create children | |
| // | |
| I2cBusContext->Controller = Controller; | |
| // | |
| // Parent controller device path used to create children device path | |
| // | |
| I2cBusContext->ParentDevicePath = ParentDevicePath; | |
| I2cBusContext->DriverBindingHandle = This->DriverBindingHandle; | |
| Status = gBS->InstallMultipleProtocolInterfaces ( | |
| &Controller, | |
| &gEfiCallerIdGuid, | |
| I2cBusContext, | |
| NULL | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG ((DEBUG_ERROR, "I2cBus: install private protocol error, Status = %r.\n", Status)); | |
| goto Error; | |
| } | |
| } | |
| // | |
| // Start the driver | |
| // | |
| Status = RegisterI2cDevice (I2cBusContext, Controller, RemainingDevicePath); | |
| return Status; | |
| Error: | |
| if (EFI_ERROR (Status)) { | |
| DEBUG ((DEBUG_ERROR, "I2cBus: Start() function failed, Status = %r\n", Status)); | |
| if (ParentDevicePath != NULL) { | |
| gBS->CloseProtocol ( | |
| Controller, | |
| &gEfiDevicePathProtocolGuid, | |
| This->DriverBindingHandle, | |
| Controller | |
| ); | |
| } | |
| if (I2cHost != NULL) { | |
| gBS->CloseProtocol ( | |
| Controller, | |
| &gEfiI2cHostProtocolGuid, | |
| This->DriverBindingHandle, | |
| Controller | |
| ); | |
| } | |
| if (I2cEnumerate != NULL) { | |
| gBS->CloseProtocol ( | |
| Controller, | |
| &gEfiI2cEnumerateProtocolGuid, | |
| This->DriverBindingHandle, | |
| Controller | |
| ); | |
| } | |
| if (I2cBusContext != NULL) { | |
| Status = gBS->UninstallMultipleProtocolInterfaces ( | |
| Controller, | |
| gEfiCallerIdGuid, | |
| I2cBusContext, | |
| NULL | |
| ); | |
| FreePool (I2cBusContext); | |
| } | |
| } | |
| // | |
| // Return the operation status. | |
| // | |
| return Status; | |
| } | |
| /** | |
| Stops a device controller or a bus controller. | |
| The Stop() function is designed to be invoked from the EFI boot service DisconnectController(). | |
| As a result, much of the error checking on the parameters to Stop() has been moved | |
| into this common boot service. It is legal to call Stop() from other locations, | |
| but the following calling restrictions must be followed or the system behavior will not be deterministic. | |
| 1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this | |
| same driver's Start() function. | |
| 2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid | |
| EFI_HANDLE. In addition, all of these handles must have been created in this driver's | |
| Start() function, and the Start() function must have called OpenProtocol() on | |
| ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER. | |
| @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. | |
| @param[in] ControllerHandle A handle to the device being stopped. The handle must | |
| support a bus specific I/O protocol for the driver | |
| to use to stop the device. | |
| @param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer. | |
| @param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL | |
| if NumberOfChildren is 0. | |
| @retval EFI_SUCCESS The device was stopped. | |
| @retval EFI_DEVICE_ERROR The device could not be stopped due to a device error. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| I2cBusDriverStop ( | |
| IN EFI_DRIVER_BINDING_PROTOCOL *This, | |
| IN EFI_HANDLE Controller, | |
| IN UINTN NumberOfChildren, | |
| IN EFI_HANDLE *ChildHandleBuffer | |
| ) | |
| { | |
| I2C_BUS_CONTEXT *I2cBusContext; | |
| EFI_STATUS Status; | |
| BOOLEAN AllChildrenStopped; | |
| UINTN Index; | |
| if (NumberOfChildren == 0) { | |
| gBS->CloseProtocol ( | |
| Controller, | |
| &gEfiDevicePathProtocolGuid, | |
| This->DriverBindingHandle, | |
| Controller | |
| ); | |
| gBS->CloseProtocol ( | |
| Controller, | |
| &gEfiI2cHostProtocolGuid, | |
| This->DriverBindingHandle, | |
| Controller | |
| ); | |
| gBS->CloseProtocol ( | |
| Controller, | |
| &gEfiI2cEnumerateProtocolGuid, | |
| This->DriverBindingHandle, | |
| Controller | |
| ); | |
| Status = gBS->OpenProtocol ( | |
| Controller, | |
| &gEfiCallerIdGuid, | |
| (VOID **)&I2cBusContext, | |
| This->DriverBindingHandle, | |
| Controller, | |
| EFI_OPEN_PROTOCOL_GET_PROTOCOL | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| gBS->UninstallMultipleProtocolInterfaces ( | |
| Controller, | |
| &gEfiCallerIdGuid, | |
| I2cBusContext, | |
| NULL | |
| ); | |
| // | |
| // No more child now, free bus context data. | |
| // | |
| FreePool (I2cBusContext); | |
| } | |
| return Status; | |
| } | |
| AllChildrenStopped = TRUE; | |
| for (Index = 0; Index < NumberOfChildren; Index++) { | |
| Status = UnRegisterI2cDevice (This, Controller, ChildHandleBuffer[Index]); | |
| if (EFI_ERROR (Status)) { | |
| AllChildrenStopped = FALSE; | |
| } | |
| } | |
| if (!AllChildrenStopped) { | |
| return EFI_DEVICE_ERROR; | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Enumerate the I2C bus | |
| This routine walks the platform specific data describing the | |
| I2C bus to create the I2C devices where driver GUIDs were | |
| specified. | |
| @param[in] I2cBusContext Address of an I2C_BUS_CONTEXT structure | |
| @param[in] Controller Handle to the controller | |
| @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. | |
| @retval EFI_SUCCESS The bus is successfully configured | |
| **/ | |
| EFI_STATUS | |
| RegisterI2cDevice ( | |
| IN I2C_BUS_CONTEXT *I2cBusContext, | |
| IN EFI_HANDLE Controller, | |
| IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath | |
| ) | |
| { | |
| I2C_DEVICE_CONTEXT *I2cDeviceContext; | |
| EFI_STATUS Status; | |
| CONST EFI_I2C_DEVICE *Device; | |
| CONST EFI_I2C_DEVICE *TempDevice; | |
| UINT32 RemainingPathDeviceIndex; | |
| EFI_DEVICE_PATH_PROTOCOL *DevPathNode; | |
| BOOLEAN BuildControllerNode; | |
| UINTN Count; | |
| Status = EFI_SUCCESS; | |
| BuildControllerNode = TRUE; | |
| // | |
| // Default DeviceIndex | |
| // | |
| RemainingPathDeviceIndex = 0; | |
| // | |
| // Determine the controller number in Controller Node Device Path when RemainingDevicePath is not NULL. | |
| // | |
| if (RemainingDevicePath != NULL) { | |
| // | |
| // Check if there is a controller node appended after vendor node | |
| // | |
| DevPathNode = NextDevicePathNode (RemainingDevicePath); | |
| if ((DevicePathType (DevPathNode) == HARDWARE_DEVICE_PATH) && | |
| (DevicePathSubType (DevPathNode) == HW_CONTROLLER_DP)) | |
| { | |
| // | |
| // RemainingDevicePath != NULL and RemainingDevicePath contains Controller Node, | |
| // add Controller Node to Device Path on child handle. | |
| // | |
| RemainingPathDeviceIndex = ((CONTROLLER_DEVICE_PATH *)DevPathNode)->ControllerNumber; | |
| } else { | |
| // | |
| // RemainingDevicePath != NULL and RemainingDevicePath does not contain Controller Node, | |
| // do not add controller node to Device Path on child handle. | |
| // | |
| BuildControllerNode = FALSE; | |
| } | |
| } | |
| // | |
| // Walk the list of I2C devices on this bus | |
| // | |
| Device = NULL; | |
| while (TRUE) { | |
| // | |
| // Get the next I2C device | |
| // | |
| Status = I2cBusContext->I2cEnumerate->Enumerate (I2cBusContext->I2cEnumerate, &Device); | |
| if (EFI_ERROR (Status) || (Device == NULL)) { | |
| if (RemainingDevicePath != NULL) { | |
| Status = EFI_NOT_FOUND; | |
| } else { | |
| Status = EFI_SUCCESS; | |
| } | |
| break; | |
| } | |
| // | |
| // Determine if the device info is valid | |
| // | |
| if ((Device->DeviceGuid == NULL) || (Device->SlaveAddressCount == 0) || (Device->SlaveAddressArray == NULL)) { | |
| DEBUG ((DEBUG_ERROR, "Invalid EFI_I2C_DEVICE reported by I2c Enumerate protocol.\n")); | |
| continue; | |
| } | |
| if (RemainingDevicePath == NULL) { | |
| if (Device->DeviceIndex == 0) { | |
| // | |
| // Determine if the controller node is necessary when controller number is zero in I2C device | |
| // | |
| TempDevice = NULL; | |
| Count = 0; | |
| while (TRUE) { | |
| // | |
| // Get the next I2C device | |
| // | |
| Status = I2cBusContext->I2cEnumerate->Enumerate (I2cBusContext->I2cEnumerate, &TempDevice); | |
| if (EFI_ERROR (Status) || (TempDevice == NULL)) { | |
| Status = EFI_SUCCESS; | |
| break; | |
| } | |
| if (CompareGuid (Device->DeviceGuid, TempDevice->DeviceGuid)) { | |
| Count++; | |
| } | |
| } | |
| if (Count == 1) { | |
| // | |
| // RemainingDevicePath == NULL and only DeviceIndex 0 is present on the I2C bus, | |
| // do not add Controller Node to Device Path on child handle. | |
| // | |
| BuildControllerNode = FALSE; | |
| } | |
| } | |
| } else { | |
| // | |
| // Find I2C device reported in Remaining Device Path | |
| // | |
| if ((!CompareGuid (&((VENDOR_DEVICE_PATH *)RemainingDevicePath)->Guid, Device->DeviceGuid)) || | |
| (RemainingPathDeviceIndex != Device->DeviceIndex)) | |
| { | |
| continue; | |
| } | |
| } | |
| // | |
| // Build the device context for current I2C device. | |
| // | |
| I2cDeviceContext = NULL; | |
| I2cDeviceContext = AllocateCopyPool (sizeof (I2C_DEVICE_CONTEXT), &gI2cDeviceContextTemplate); | |
| ASSERT (I2cDeviceContext != NULL); | |
| if (I2cDeviceContext == NULL) { | |
| continue; | |
| } | |
| // | |
| // Initialize the specific device context | |
| // | |
| I2cDeviceContext->I2cBusContext = I2cBusContext; | |
| I2cDeviceContext->I2cDevice = Device; | |
| I2cDeviceContext->I2cIo.DeviceGuid = Device->DeviceGuid; | |
| I2cDeviceContext->I2cIo.DeviceIndex = Device->DeviceIndex; | |
| I2cDeviceContext->I2cIo.HardwareRevision = Device->HardwareRevision; | |
| I2cDeviceContext->I2cIo.I2cControllerCapabilities = I2cBusContext->I2cHost->I2cControllerCapabilities; | |
| // | |
| // Build the device path | |
| // | |
| Status = I2cBusDevicePathAppend (I2cDeviceContext, BuildControllerNode); | |
| ASSERT_EFI_ERROR (Status); | |
| if (EFI_ERROR (Status)) { | |
| continue; | |
| } | |
| // | |
| // Install the protocol | |
| // | |
| Status = gBS->InstallMultipleProtocolInterfaces ( | |
| &I2cDeviceContext->Handle, | |
| &gEfiI2cIoProtocolGuid, | |
| &I2cDeviceContext->I2cIo, | |
| &gEfiDevicePathProtocolGuid, | |
| I2cDeviceContext->DevicePath, | |
| NULL | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| // | |
| // Free resources for this I2C device | |
| // | |
| ReleaseI2cDeviceContext (I2cDeviceContext); | |
| continue; | |
| } | |
| // | |
| // Create the child handle | |
| // | |
| Status = gBS->OpenProtocol ( | |
| Controller, | |
| &gEfiI2cHostProtocolGuid, | |
| (VOID **)&I2cBusContext->I2cHost, | |
| I2cBusContext->DriverBindingHandle, | |
| I2cDeviceContext->Handle, | |
| EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| Status = gBS->UninstallMultipleProtocolInterfaces ( | |
| I2cDeviceContext->Handle, | |
| &gEfiDevicePathProtocolGuid, | |
| I2cDeviceContext->DevicePath, | |
| &gEfiI2cIoProtocolGuid, | |
| &I2cDeviceContext->I2cIo, | |
| NULL | |
| ); | |
| // | |
| // Free resources for this I2C device | |
| // | |
| ReleaseI2cDeviceContext (I2cDeviceContext); | |
| continue; | |
| } | |
| if (RemainingDevicePath != NULL) { | |
| // | |
| // Child has been created successfully | |
| // | |
| break; | |
| } | |
| } | |
| return Status; | |
| } | |
| /** | |
| Queue an I2C transaction for execution on the I2C device. | |
| This routine must be called at or below TPL_NOTIFY. For synchronous | |
| requests this routine must be called at or below TPL_CALLBACK. | |
| This routine queues an I2C transaction to the I2C controller for | |
| execution on the I2C bus. | |
| When Event is NULL, QueueRequest() operates synchronously and returns | |
| the I2C completion status as its return value. | |
| When Event is not NULL, QueueRequest() synchronously returns EFI_SUCCESS | |
| indicating that the asynchronous I2C transaction was queued. The values | |
| above are returned in the buffer pointed to by I2cStatus upon the | |
| completion of the I2C transaction when I2cStatus is not NULL. | |
| The upper layer driver writer provides the following to the platform | |
| vendor: | |
| 1. Vendor specific GUID for the I2C part | |
| 2. Guidance on proper construction of the slave address array when the | |
| I2C device uses more than one slave address. The I2C bus protocol | |
| uses the SlaveAddressIndex to perform relative to physical address | |
| translation to access the blocks of hardware within the I2C device. | |
| @param[in] This Pointer to an EFI_I2C_IO_PROTOCOL structure. | |
| @param[in] SlaveAddressIndex Index value into an array of slave addresses | |
| for the I2C device. The values in the array | |
| are specified by the board designer, with the | |
| third party I2C device driver writer providing | |
| the slave address order. | |
| For devices that have a single slave address, | |
| this value must be zero. If the I2C device | |
| uses more than one slave address then the | |
| third party (upper level) I2C driver writer | |
| needs to specify the order of entries in the | |
| slave address array. | |
| \ref ThirdPartyI2cDrivers "Third Party I2C | |
| Drivers" section in I2cMaster.h. | |
| @param[in] Event Event to signal for asynchronous transactions, | |
| NULL for synchronous transactions | |
| @param[in] RequestPacket Pointer to an EFI_I2C_REQUEST_PACKET structure | |
| describing the I2C transaction | |
| @param[out] I2cStatus Optional buffer to receive the I2C transaction | |
| completion status | |
| @retval EFI_SUCCESS The asynchronous transaction was successfully | |
| queued when Event is not NULL. | |
| @retval EFI_SUCCESS The transaction completed successfully when | |
| Event is NULL. | |
| @retval EFI_BAD_BUFFER_SIZE The RequestPacket->LengthInBytes value is too | |
| large. | |
| @retval EFI_DEVICE_ERROR There was an I2C error (NACK) during the | |
| transaction. | |
| @retval EFI_INVALID_PARAMETER RequestPacket is NULL | |
| @retval EFI_NO_MAPPING The EFI_I2C_HOST_PROTOCOL could not set the | |
| bus configuration required to access this I2C | |
| device. | |
| @retval EFI_NO_RESPONSE The I2C device is not responding to the slave | |
| address selected by SlaveAddressIndex. | |
| EFI_DEVICE_ERROR will be returned if the | |
| controller cannot distinguish when the NACK | |
| occurred. | |
| @retval EFI_OUT_OF_RESOURCES Insufficient memory for I2C transaction | |
| @retval EFI_UNSUPPORTED The controller does not support the requested | |
| transaction. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| I2cBusQueueRequest ( | |
| IN CONST EFI_I2C_IO_PROTOCOL *This, | |
| IN UINTN SlaveAddressIndex, | |
| IN EFI_EVENT Event OPTIONAL, | |
| IN EFI_I2C_REQUEST_PACKET *RequestPacket, | |
| OUT EFI_STATUS *I2cStatus OPTIONAL | |
| ) | |
| { | |
| CONST EFI_I2C_DEVICE *I2cDevice; | |
| I2C_BUS_CONTEXT *I2cBusContext; | |
| CONST EFI_I2C_HOST_PROTOCOL *I2cHost; | |
| I2C_DEVICE_CONTEXT *I2cDeviceContext; | |
| EFI_STATUS Status; | |
| if (RequestPacket == NULL) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| // | |
| // Validate the I2C slave index | |
| // | |
| I2cDeviceContext = I2C_DEVICE_CONTEXT_FROM_PROTOCOL (This); | |
| I2cDevice = I2cDeviceContext->I2cDevice; | |
| if ( SlaveAddressIndex >= I2cDevice->SlaveAddressCount ) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| // | |
| // Locate the I2c Host Protocol to queue request | |
| // | |
| I2cBusContext = I2cDeviceContext->I2cBusContext; | |
| I2cHost = I2cBusContext->I2cHost; | |
| // | |
| // Start the I2C operation | |
| // | |
| Status = I2cHost->QueueRequest ( | |
| I2cHost, | |
| I2cDevice->I2cBusConfiguration, | |
| I2cDevice->SlaveAddressArray[SlaveAddressIndex], | |
| Event, | |
| RequestPacket, | |
| I2cStatus | |
| ); | |
| return Status; | |
| } | |
| /** | |
| Release all the resources allocated for the I2C device. | |
| This function releases all the resources allocated for the I2C device. | |
| @param I2cDeviceContext The I2C child device involved for the operation. | |
| **/ | |
| VOID | |
| ReleaseI2cDeviceContext ( | |
| IN I2C_DEVICE_CONTEXT *I2cDeviceContext | |
| ) | |
| { | |
| if (I2cDeviceContext == NULL) { | |
| return; | |
| } | |
| if (I2cDeviceContext->DevicePath != NULL) { | |
| FreePool (I2cDeviceContext->DevicePath); | |
| } | |
| FreePool (I2cDeviceContext); | |
| } | |
| /** | |
| Unregister an I2C device. | |
| This function removes the protocols installed on the controller handle and | |
| frees the resources allocated for the I2C device. | |
| @param This The pointer to EFI_DRIVER_BINDING_PROTOCOL instance. | |
| @param Controller The controller handle of the I2C device. | |
| @param Handle The child handle. | |
| @retval EFI_SUCCESS The I2C device is successfully unregistered. | |
| @return Others Some error occurs when unregistering the I2C device. | |
| **/ | |
| EFI_STATUS | |
| UnRegisterI2cDevice ( | |
| IN EFI_DRIVER_BINDING_PROTOCOL *This, | |
| IN EFI_HANDLE Controller, | |
| IN EFI_HANDLE Handle | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| I2C_DEVICE_CONTEXT *I2cDeviceContext; | |
| EFI_I2C_IO_PROTOCOL *I2cIo; | |
| EFI_I2C_HOST_PROTOCOL *I2cHost; | |
| I2cIo = NULL; | |
| Status = gBS->OpenProtocol ( | |
| Handle, | |
| &gEfiI2cIoProtocolGuid, | |
| (VOID **)&I2cIo, | |
| This->DriverBindingHandle, | |
| Controller, | |
| EFI_OPEN_PROTOCOL_GET_PROTOCOL | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| // | |
| // Get I2c device context data. | |
| // | |
| I2cDeviceContext = I2C_DEVICE_CONTEXT_FROM_PROTOCOL (I2cIo); | |
| // | |
| // Close the child handle | |
| // | |
| gBS->CloseProtocol ( | |
| Controller, | |
| &gEfiI2cHostProtocolGuid, | |
| This->DriverBindingHandle, | |
| Handle | |
| ); | |
| // | |
| // The I2C Bus driver installs the I2C Io and Device Path Protocol in the DriverBindingStart(). | |
| // Here should uninstall them. | |
| // | |
| Status = gBS->UninstallMultipleProtocolInterfaces ( | |
| Handle, | |
| &gEfiDevicePathProtocolGuid, | |
| I2cDeviceContext->DevicePath, | |
| &gEfiI2cIoProtocolGuid, | |
| &I2cDeviceContext->I2cIo, | |
| NULL | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| // | |
| // Keep parent and child relationship | |
| // | |
| gBS->OpenProtocol ( | |
| Controller, | |
| &gEfiI2cHostProtocolGuid, | |
| (VOID **)&I2cHost, | |
| This->DriverBindingHandle, | |
| Handle, | |
| EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER | |
| ); | |
| return Status; | |
| } | |
| // | |
| // Free resources for this I2C device | |
| // | |
| ReleaseI2cDeviceContext (I2cDeviceContext); | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Create a path for the I2C device | |
| Append the I2C slave path to the I2C master controller path. | |
| @param[in] I2cDeviceContext Address of an I2C_DEVICE_CONTEXT structure. | |
| @param[in] BuildControllerNode Flag to build controller node in device path. | |
| @retval EFI_SUCCESS The I2C device path is built successfully. | |
| @return Others It is failed to built device path. | |
| **/ | |
| EFI_STATUS | |
| I2cBusDevicePathAppend ( | |
| IN I2C_DEVICE_CONTEXT *I2cDeviceContext, | |
| IN BOOLEAN BuildControllerNode | |
| ) | |
| { | |
| EFI_DEVICE_PATH_PROTOCOL *PreviousDevicePath; | |
| PreviousDevicePath = NULL; | |
| // | |
| // Build vendor device path | |
| // | |
| CopyMem (&gVendorDevicePathTemplate.Guid, I2cDeviceContext->I2cDevice->DeviceGuid, sizeof (EFI_GUID)); | |
| I2cDeviceContext->DevicePath = AppendDevicePathNode ( | |
| I2cDeviceContext->I2cBusContext->ParentDevicePath, | |
| (EFI_DEVICE_PATH_PROTOCOL *)&gVendorDevicePathTemplate | |
| ); | |
| ASSERT (I2cDeviceContext->DevicePath != NULL); | |
| if (I2cDeviceContext->DevicePath == NULL) { | |
| return EFI_OUT_OF_RESOURCES; | |
| } | |
| if ((BuildControllerNode) && (I2cDeviceContext->DevicePath != NULL)) { | |
| // | |
| // Build the final I2C device path with controller node | |
| // | |
| PreviousDevicePath = I2cDeviceContext->DevicePath; | |
| gControllerDevicePathTemplate.ControllerNumber = I2cDeviceContext->I2cDevice->DeviceIndex; | |
| I2cDeviceContext->DevicePath = AppendDevicePathNode ( | |
| I2cDeviceContext->DevicePath, | |
| (EFI_DEVICE_PATH_PROTOCOL *)&gControllerDevicePathTemplate | |
| ); | |
| gBS->FreePool (PreviousDevicePath); | |
| ASSERT (I2cDeviceContext->DevicePath != NULL); | |
| if (I2cDeviceContext->DevicePath == NULL) { | |
| return EFI_OUT_OF_RESOURCES; | |
| } | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| The user entry point for the I2C bus module. The user code starts with | |
| this function. | |
| @param[in] ImageHandle The firmware allocated handle for the EFI image. | |
| @param[in] SystemTable A pointer to the EFI System Table. | |
| @retval EFI_SUCCESS The entry point is executed successfully. | |
| @retval other Some error occurs when executing this entry point. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| InitializeI2cBus ( | |
| IN EFI_HANDLE ImageHandle, | |
| IN EFI_SYSTEM_TABLE *SystemTable | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| // | |
| // Install driver model protocol(s). | |
| // | |
| Status = EfiLibInstallDriverBindingComponentName2 ( | |
| ImageHandle, | |
| SystemTable, | |
| &gI2cBusDriverBinding, | |
| NULL, | |
| &gI2cBusComponentName, | |
| &gI2cBusComponentName2 | |
| ); | |
| ASSERT_EFI_ERROR (Status); | |
| return Status; | |
| } | |
| /** | |
| This is the unload handle for I2C bus module. | |
| Disconnect the driver specified by ImageHandle from all the devices in the handle database. | |
| Uninstall all the protocols installed in the driver entry point. | |
| @param[in] ImageHandle The drivers' driver image. | |
| @retval EFI_SUCCESS The image is unloaded. | |
| @retval Others Failed to unload the image. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| I2cBusUnload ( | |
| IN EFI_HANDLE ImageHandle | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_HANDLE *DeviceHandleBuffer; | |
| UINTN DeviceHandleCount; | |
| UINTN Index; | |
| EFI_COMPONENT_NAME_PROTOCOL *ComponentName; | |
| EFI_COMPONENT_NAME2_PROTOCOL *ComponentName2; | |
| // | |
| // Get the list of all I2C Controller handles in the handle database. | |
| // If there is an error getting the list, then the unload | |
| // operation fails. | |
| // | |
| Status = gBS->LocateHandleBuffer ( | |
| ByProtocol, | |
| &gEfiI2cHostProtocolGuid, | |
| NULL, | |
| &DeviceHandleCount, | |
| &DeviceHandleBuffer | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| // | |
| // Disconnect the driver specified by Driver BindingHandle from all | |
| // the devices in the handle database. | |
| // | |
| for (Index = 0; Index < DeviceHandleCount; Index++) { | |
| Status = gBS->DisconnectController ( | |
| DeviceHandleBuffer[Index], | |
| gI2cBusDriverBinding.DriverBindingHandle, | |
| NULL | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| goto Done; | |
| } | |
| } | |
| } | |
| // | |
| // Uninstall all the protocols installed in the driver entry point | |
| // | |
| Status = gBS->UninstallMultipleProtocolInterfaces ( | |
| gI2cBusDriverBinding.DriverBindingHandle, | |
| &gEfiDriverBindingProtocolGuid, | |
| &gI2cBusDriverBinding, | |
| NULL | |
| ); | |
| ASSERT_EFI_ERROR (Status); | |
| // | |
| // Note we have to one by one uninstall the following protocols. | |
| // It's because some of them are optionally installed based on | |
| // the following PCD settings. | |
| // gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnosticsDisable | |
| // gEfiMdePkgTokenSpaceGuid.PcdComponentNameDisable | |
| // gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnostics2Disable | |
| // gEfiMdePkgTokenSpaceGuid.PcdComponentName2Disable | |
| // | |
| Status = gBS->HandleProtocol ( | |
| gI2cBusDriverBinding.DriverBindingHandle, | |
| &gEfiComponentNameProtocolGuid, | |
| (VOID **)&ComponentName | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| gBS->UninstallProtocolInterface ( | |
| gI2cBusDriverBinding.DriverBindingHandle, | |
| &gEfiComponentNameProtocolGuid, | |
| ComponentName | |
| ); | |
| } | |
| Status = gBS->HandleProtocol ( | |
| gI2cBusDriverBinding.DriverBindingHandle, | |
| &gEfiComponentName2ProtocolGuid, | |
| (VOID **)&ComponentName2 | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| gBS->UninstallProtocolInterface ( | |
| gI2cBusDriverBinding.DriverBindingHandle, | |
| &gEfiComponentName2ProtocolGuid, | |
| ComponentName2 | |
| ); | |
| } | |
| Status = EFI_SUCCESS; | |
| Done: | |
| // | |
| // Free the buffer containing the list of handles from the handle database | |
| // | |
| if (DeviceHandleBuffer != NULL) { | |
| gBS->FreePool (DeviceHandleBuffer); | |
| } | |
| return Status; | |
| } |