iPXE
Functions | Variables
efi_driver.c File Reference

EFI driver interface. More...

#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <ipxe/version.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/Protocol/DriverBinding.h>
#include <ipxe/efi/Protocol/ComponentName2.h>
#include <ipxe/efi/Protocol/DevicePath.h>
#include <ipxe/efi/efi_strings.h>
#include <ipxe/efi/efi_utils.h>
#include <ipxe/efi/efi_driver.h>

Go to the source code of this file.

Functions

 FILE_LICENCE (GPL2_OR_LATER)
static LIST_HEAD (efi_devices)
 List of controlled EFI devices.
static struct efi_deviceefidev_find (EFI_HANDLE device)
 Find EFI device.
struct efi_deviceefidev_parent (struct device *dev)
 Get parent EFI device.
static EFI_STATUS EFIAPI efi_driver_supported (EFI_DRIVER_BINDING_PROTOCOL *driver __unused, EFI_HANDLE device, EFI_DEVICE_PATH_PROTOCOL *child)
 Check to see if driver supports a device.
static EFI_STATUS EFIAPI efi_driver_start (EFI_DRIVER_BINDING_PROTOCOL *driver __unused, EFI_HANDLE device, EFI_DEVICE_PATH_PROTOCOL *child)
 Attach driver to device.
static EFI_STATUS EFIAPI efi_driver_stop (EFI_DRIVER_BINDING_PROTOCOL *driver __unused, EFI_HANDLE device, UINTN num_children, EFI_HANDLE *children)
 Detach driver from device.
static EFI_STATUS EFIAPI efi_driver_name (EFI_COMPONENT_NAME2_PROTOCOL *wtf __unused, CHAR8 *language __unused, CHAR16 **driver_name)
 Look up driver name.
static EFI_STATUS EFIAPI efi_driver_controller_name (EFI_COMPONENT_NAME2_PROTOCOL *wtf __unused, EFI_HANDLE device, EFI_HANDLE child, CHAR8 *language, CHAR16 **controller_name)
 Look up controller name.
int efi_driver_install (void)
 Install EFI driver.
void efi_driver_uninstall (void)
 Uninstall EFI driver.
static int efi_driver_connect (EFI_HANDLE device)
 Try to connect EFI driver.
static int efi_driver_disconnect (EFI_HANDLE device)
 Try to disconnect EFI driver.
static int efi_driver_reconnect (EFI_HANDLE device)
 Reconnect original EFI driver.
static int efi_driver_handles (int(*method)(EFI_HANDLE handle))
 Connect/disconnect EFI driver from all handles.
int efi_driver_connect_all (void)
 Connect EFI driver to all possible devices.
void efi_driver_disconnect_all (void)
 Disconnect EFI driver from all possible devices.
void efi_driver_reconnect_all (void)
 Reconnect original EFI drivers to all possible devices.

Variables

static EFI_DRIVER_BINDING_PROTOCOL efi_driver_binding
 EFI driver binding protocol.
static int efi_driver_disconnecting
 We are currently disconnecting drivers.
static EFI_COMPONENT_NAME2_PROTOCOL efi_wtf
 EFI component name protocol.

Detailed Description

EFI driver interface.

Definition in file efi_driver.c.


Function Documentation

FILE_LICENCE ( GPL2_OR_LATER  )
static LIST_HEAD ( efi_devices  ) [static]

List of controlled EFI devices.

static struct efi_device* efidev_find ( EFI_HANDLE  device) [static, read]

Find EFI device.

Parameters:
deviceEFI device handle
Return values:
efidevEFI device, or NULL if not found

Definition at line 56 of file efi_driver.c.

References efi_device::dev, efi_device::device, list_for_each_entry, NULL, and device::siblings.

Referenced by efi_driver_start(), efi_driver_stop(), and efi_driver_supported().

                                                             {
        struct efi_device *efidev;

        /* Look for an existing EFI device */
        list_for_each_entry ( efidev, &efi_devices, dev.siblings ) {
                if ( efidev->device == device )
                        return efidev;
        }

        return NULL;
}
struct efi_device* efidev_parent ( struct device dev) [read]

Get parent EFI device.

Parameters:
devGeneric device
Return values:
efidevParent EFI device, or NULL

Definition at line 74 of file efi_driver.c.

References device_description::bus_type, BUS_TYPE_EFI, container_of, device::desc, NULL, and device::parent.

Referenced by efi_snp_probe(), and efi_usb_probe().

                                                         {
        struct device *parent;

        /* Walk upwards until we find an EFI device */
        while ( ( parent = dev->parent ) ) {
                if ( parent->desc.bus_type == BUS_TYPE_EFI )
                        return container_of ( parent, struct efi_device, dev );
                dev = parent;
        }

        return NULL;
}

Check to see if driver supports a device.

Parameters:
driverEFI driver
deviceEFI device
childPath to child device, if any
Return values:
efircEFI status code

Definition at line 96 of file efi_driver.c.

References DBGC, DBGCP, EFI_ALREADY_STARTED, efi_devpath_text(), EFI_DRIVERS, efi_handle_name(), EFI_UNSUPPORTED, efidev_find(), for_each_table_entry, efi_driver::name, NULL, rc, and efi_driver::supported.

Referenced by efi_driver_connect().

                                                                            {
        struct efi_driver *efidrv;
        int rc;

        DBGCP ( device, "EFIDRV %s DRIVER_SUPPORTED",
                efi_handle_name ( device ) );
        if ( child )
                DBGCP ( device, " (child %s)", efi_devpath_text ( child ) );
        DBGCP ( device, "\n" );

        /* Do nothing if we are already driving this device */
        if ( efidev_find ( device ) != NULL ) {
                DBGCP ( device, "EFIDRV %s is already started\n",
                        efi_handle_name ( device ) );
                return EFI_ALREADY_STARTED;
        }

        /* Look for a driver claiming to support this device */
        for_each_table_entry ( efidrv, EFI_DRIVERS ) {
                if ( ( rc = efidrv->supported ( device ) ) == 0 ) {
                        DBGC ( device, "EFIDRV %s has driver \"%s\"\n",
                               efi_handle_name ( device ), efidrv->name );
                        return 0;
                }
        }
        DBGCP ( device, "EFIDRV %s has no driver\n",
                efi_handle_name ( device ) );

        return EFI_UNSUPPORTED;
}

Attach driver to device.

Parameters:
driverEFI driver
deviceEFI device
childPath to child device, if any
Return values:
efircEFI status code

Definition at line 137 of file efi_driver.c.

References EFI_SYSTEM_TABLE::BootServices, device_description::bus_type, BUS_TYPE_EFI, device::children, EFI_BOOT_SERVICES::CloseProtocol, DBGC, DBGCP, device::desc, efi_device::dev, efi_device::device, device, efi_device::driver, EEFI, EFI_ALREADY_STARTED, efi_device_path_protocol_guid, efi_devpath_len(), efi_devpath_text(), efi_driver_disconnecting, EFI_DRIVERS, efi_handle_name(), efi_image_handle, EFI_NOT_READY, EFI_OPEN_PROTOCOL_GET_PROTOCOL, EFI_OUT_OF_RESOURCES, efi_systab, EFI_UNSUPPORTED, efidev_find(), for_each_table_entry, free, INIT_LIST_HEAD, list_add, list_del, memcpy(), efi_driver::name, NULL, EFI_BOOT_SERVICES::OpenProtocol, efi_device::path, EFI_BOOT_SERVICES::RaiseTPL, rc, EFI_BOOT_SERVICES::RestoreTPL, device::siblings, efi_driver::start, strerror(), efi_driver::supported, TPL_CALLBACK, and zalloc().

                                                                        {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct efi_driver *efidrv;
        struct efi_device *efidev;
        union {
                EFI_DEVICE_PATH_PROTOCOL *path;
                void *interface;
        } path;
        EFI_DEVICE_PATH_PROTOCOL *path_end;
        size_t path_len;
        EFI_TPL saved_tpl;
        EFI_STATUS efirc;
        int rc;

        DBGC ( device, "EFIDRV %s DRIVER_START", efi_handle_name ( device ) );
        if ( child )
                DBGC ( device, " (child %s)", efi_devpath_text ( child ) );
        DBGC ( device, "\n" );

        /* Do nothing if we are already driving this device */
        efidev = efidev_find ( device );
        if ( efidev ) {
                DBGCP ( device, "EFIDRV %s is already started\n",
                        efi_handle_name ( device ) );
                efirc = EFI_ALREADY_STARTED;
                goto err_already_started;
        }

        /* Raise TPL */
        saved_tpl = bs->RaiseTPL ( TPL_CALLBACK );

        /* Do nothing if we are currently disconnecting drivers */
        if ( efi_driver_disconnecting ) {
                DBGC ( device, "EFIDRV %s refusing to start during "
                       "disconnection\n", efi_handle_name ( device ) );
                efirc = EFI_NOT_READY;
                goto err_disconnecting;
        }

        /* Open device path */
        if ( ( efirc = bs->OpenProtocol ( device,
                                          &efi_device_path_protocol_guid,
                                          &path.interface, efi_image_handle,
                                          device,
                                          EFI_OPEN_PROTOCOL_GET_PROTOCOL ))!=0){
                rc = -EEFI ( efirc );
                DBGC ( device, "EFIDRV %s could not open device path: %s\n",
                       efi_handle_name ( device ), strerror ( rc ) );
                goto err_open_path;
        }
        path_len = ( efi_devpath_len ( path.path ) + sizeof ( *path_end ) );

        /* Allocate and initialise structure */
        efidev = zalloc ( sizeof ( *efidev ) + path_len );
        if ( ! efidev ) {
                efirc = EFI_OUT_OF_RESOURCES;
                goto err_alloc;
        }
        efidev->device = device;
        efidev->dev.desc.bus_type = BUS_TYPE_EFI;
        efidev->path = ( ( ( void * ) efidev ) + sizeof ( *efidev ) );
        memcpy ( efidev->path, path.path, path_len );
        INIT_LIST_HEAD ( &efidev->dev.children );
        list_add ( &efidev->dev.siblings, &efi_devices );

        /* Close device path */
        bs->CloseProtocol ( device, &efi_device_path_protocol_guid,
                            efi_image_handle, device );
        path.path = NULL;

        /* Try to start this device */
        for_each_table_entry ( efidrv, EFI_DRIVERS ) {
                if ( ( rc = efidrv->supported ( device ) ) != 0 ) {
                        DBGC ( device, "EFIDRV %s is not supported by driver "
                               "\"%s\": %s\n", efi_handle_name ( device ),
                               efidrv->name,
                               strerror ( rc ) );
                        continue;
                }
                if ( ( rc = efidrv->start ( efidev ) ) == 0 ) {
                        efidev->driver = efidrv;
                        DBGC ( device, "EFIDRV %s using driver \"%s\"\n",
                               efi_handle_name ( device ),
                               efidev->driver->name );
                        bs->RestoreTPL ( saved_tpl );
                        return 0;
                }
                DBGC ( device, "EFIDRV %s could not start driver \"%s\": %s\n",
                       efi_handle_name ( device ), efidrv->name,
                       strerror ( rc ) );
        }
        efirc = EFI_UNSUPPORTED;

        list_del ( &efidev->dev.siblings );
        free ( efidev );
 err_alloc:
        if ( path.path ) {
                bs->CloseProtocol ( device, &efi_device_path_protocol_guid,
                                    efi_image_handle, device );
        }
 err_open_path:
 err_disconnecting:
        bs->RestoreTPL ( saved_tpl );
 err_already_started:
        return efirc;
}
static EFI_STATUS EFIAPI efi_driver_stop ( EFI_DRIVER_BINDING_PROTOCOL *driver  __unused,
EFI_HANDLE  device,
UINTN  num_children,
EFI_HANDLE children 
) [static]

Detach driver from device.

Parameters:
driverEFI driver
deviceEFI device
pciPCI device
num_childrenNumber of child devices
childrenList of child devices
Return values:
efircEFI status code

Definition at line 256 of file efi_driver.c.

References assert, EFI_SYSTEM_TABLE::BootServices, DBGC, DBGCP, efi_device::dev, efi_device::driver, EFI_DEVICE_ERROR, efi_handle_name(), efi_systab, efidev_find(), free, list_del, NULL, EFI_BOOT_SERVICES::RaiseTPL, EFI_BOOT_SERVICES::RestoreTPL, device::siblings, efi_driver::stop, and TPL_CALLBACK.

                                         {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct efi_driver *efidrv;
        struct efi_device *efidev;
        EFI_TPL saved_tpl;
        UINTN i;

        DBGC ( device, "EFIDRV %s DRIVER_STOP", efi_handle_name ( device ) );
        for ( i = 0 ; i < num_children ; i++ ) {
                DBGC ( device, "%s%s", ( i ? ", " : " child " ),
                       efi_handle_name ( children[i] ) );
        }
        DBGC ( device, "\n" );

        /* Do nothing unless we are driving this device */
        efidev = efidev_find ( device );
        if ( ! efidev ) {
                DBGCP ( device, "EFIDRV %s is not started\n",
                        efi_handle_name ( device ) );
                return EFI_DEVICE_ERROR;
        }

        /* Raise TPL */
        saved_tpl = bs->RaiseTPL ( TPL_CALLBACK );

        /* Stop this device */
        efidrv = efidev->driver;
        assert ( efidrv != NULL );
        efidrv->stop ( efidev );
        list_del ( &efidev->dev.siblings );
        free ( efidev );

        bs->RestoreTPL ( saved_tpl );
        return 0;
}
static EFI_STATUS EFIAPI efi_driver_name ( EFI_COMPONENT_NAME2_PROTOCOL *wtf  __unused,
CHAR8 *language  __unused,
CHAR16 **  driver_name 
) [static]

Look up driver name.

Parameters:
wtfComponent name protocol
languageLanguage to use
driver_nameDriver name to fill in
Return values:
efircEFI status code

Definition at line 310 of file efi_driver.c.

References build_wname, name, and product_wname.

                                                                   {
        const wchar_t *name;

        name = ( product_wname[0] ? product_wname : build_wname );
        *driver_name = ( ( wchar_t * ) name );
        return 0;
}
static EFI_STATUS EFIAPI efi_driver_controller_name ( EFI_COMPONENT_NAME2_PROTOCOL *wtf  __unused,
EFI_HANDLE  device,
EFI_HANDLE  child,
CHAR8 language,
CHAR16 **  controller_name 
) [static]

Look up controller name.

Parameters:
wtfComponent name protocol
deviceDevice
childChild device, or NULL
languageLanguage to use
driver_nameDevice name to fill in
Return values:
efircEFI status code

Definition at line 330 of file efi_driver.c.

References EFI_SYSTEM_TABLE::BootServices, efi_component_name2_protocol_guid, EFI_OPEN_PROTOCOL_GET_PROTOCOL, efi_systab, EFI_UNSUPPORTED, NULL, and EFI_BOOT_SERVICES::OpenProtocol.

                                                                         {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        union {
                EFI_COMPONENT_NAME2_PROTOCOL *name2;
                void *interface;
        } name2;
        EFI_STATUS efirc;

        /* Delegate to the EFI_COMPONENT_NAME2_PROTOCOL instance
         * installed on child handle, if present.
         */
        if ( ( child != NULL ) &&
             ( ( efirc = bs->OpenProtocol (
                          child, &efi_component_name2_protocol_guid,
                          &name2.interface, NULL, NULL,
                          EFI_OPEN_PROTOCOL_GET_PROTOCOL ) ) == 0 ) ) {
                return name2.name2->GetControllerName ( name2.name2, device,
                                                        child, language,
                                                        controller_name );
        }

        /* Otherwise, let EFI use the default Device Path Name */
        return EFI_UNSUPPORTED;
}
int efi_driver_install ( void  )

Install EFI driver.

Return values:
rcReturn status code

Definition at line 369 of file efi_driver.c.

References EFI_SYSTEM_TABLE::BootServices, build_timestamp, DBGC, _EFI_DRIVER_BINDING_PROTOCOL::DriverBindingHandle, EEFI, efi_component_name2_protocol_guid, efi_driver_binding_protocol_guid, efi_image_handle, efi_systab, _EFI_DRIVER_BINDING_PROTOCOL::ImageHandle, EFI_BOOT_SERVICES::InstallMultipleProtocolInterfaces, NULL, rc, strerror(), and _EFI_DRIVER_BINDING_PROTOCOL::Version.

Referenced by efi_init().

                                {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_STATUS efirc;
        int rc;

        /* Calculate driver version number.  We use the build
         * timestamp (in seconds since the Epoch) shifted right by six
         * bits: this gives us an approximately one-minute resolution
         * and a scheme which will last until the year 10680.
         */
        efi_driver_binding.Version = ( build_timestamp >> 6 );

        /* Install protocols on image handle */
        efi_driver_binding.ImageHandle = efi_image_handle;
        efi_driver_binding.DriverBindingHandle = efi_image_handle;
        if ( ( efirc = bs->InstallMultipleProtocolInterfaces (
                        &efi_image_handle,
                        &efi_driver_binding_protocol_guid, &efi_driver_binding,
                        &efi_component_name2_protocol_guid, &efi_wtf,
                        NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( &efi_driver_binding, "EFIDRV could not install "
                       "protocols: %s\n", strerror ( rc ) );
                return rc;
        }

        return 0;
}
void efi_driver_uninstall ( void  )
static int efi_driver_connect ( EFI_HANDLE  device) [static]

Try to connect EFI driver.

Parameters:
deviceEFI device
Return values:
rcReturn status code

Definition at line 418 of file efi_driver.c.

References EFI_SYSTEM_TABLE::BootServices, EFI_BOOT_SERVICES::ConnectController, DBGC, DBGC2, DBGC2_EFI_PROTOCOLS, EFI_BOOT_SERVICES::DisconnectController, _EFI_DRIVER_BINDING_PROTOCOL::DriverBindingHandle, EEFI, efi_driver_disconnecting, efi_driver_supported(), efi_handle_name(), efi_systab, FALSE, NULL, rc, and strerror().

Referenced by efi_driver_connect_all().

                                                    {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_HANDLE drivers[2] =
                { efi_driver_binding.DriverBindingHandle, NULL };
        EFI_STATUS efirc;
        int rc;

        /* Check if we want to drive this device */
        if ( ( efirc = efi_driver_supported ( &efi_driver_binding, device,
                                              NULL ) ) != 0 ) {
                /* Not supported; not an error */
                return 0;
        }

        /* Disconnect any existing drivers */
        DBGC2 ( device, "EFIDRV %s before disconnecting:\n",
                efi_handle_name ( device ) );
        DBGC2_EFI_PROTOCOLS ( device, device );
        DBGC ( device, "EFIDRV %s disconnecting existing drivers\n",
               efi_handle_name ( device ) );
        efi_driver_disconnecting = 1;
        if ( ( efirc = bs->DisconnectController ( device, NULL,
                                                  NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( device, "EFIDRV %s could not disconnect existing "
                       "drivers: %s\n", efi_handle_name ( device ),
                       strerror ( rc ) );
                /* Ignore the error and attempt to connect our drivers */
        }
        efi_driver_disconnecting = 0;
        DBGC2 ( device, "EFIDRV %s after disconnecting:\n",
                efi_handle_name ( device ) );
        DBGC2_EFI_PROTOCOLS ( device, device );

        /* Connect our driver */
        DBGC ( device, "EFIDRV %s connecting new drivers\n",
               efi_handle_name ( device ) );
        if ( ( efirc = bs->ConnectController ( device, drivers, NULL,
                                               FALSE ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( device, "EFIDRV %s could not connect new drivers: "
                       "%s\n", efi_handle_name ( device ), strerror ( rc ) );
                return rc;
        }
        DBGC2 ( device, "EFIDRV %s after connecting:\n",
                efi_handle_name ( device ) );
        DBGC2_EFI_PROTOCOLS ( device, device );

        return 0;
}
static int efi_driver_disconnect ( EFI_HANDLE  device) [static]

Try to disconnect EFI driver.

Parameters:
deviceEFI device
Return values:
rcReturn status code

Definition at line 475 of file efi_driver.c.

References EFI_SYSTEM_TABLE::BootServices, EFI_BOOT_SERVICES::DisconnectController, _EFI_DRIVER_BINDING_PROTOCOL::DriverBindingHandle, efi_driver_disconnecting, efi_systab, and NULL.

Referenced by efi_driver_disconnect_all().

static int efi_driver_reconnect ( EFI_HANDLE  device) [static]

Reconnect original EFI driver.

Parameters:
deviceEFI device
Return values:
rcReturn status code

Definition at line 493 of file efi_driver.c.

References EFI_SYSTEM_TABLE::BootServices, EFI_BOOT_SERVICES::ConnectController, efi_systab, FALSE, and NULL.

Referenced by efi_driver_reconnect_all().

                                                      {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;

        /* Reconnect any available driver */
        bs->ConnectController ( device, NULL, NULL, FALSE );

        return 0;
}
static int efi_driver_handles ( int(*)(EFI_HANDLE handle method) [static]

Connect/disconnect EFI driver from all handles.

Parameters:
methodConnect/disconnect method
Return values:
rcReturn status code

Definition at line 508 of file efi_driver.c.

References AllHandles, EFI_SYSTEM_TABLE::BootServices, DBGC, EEFI, efi_systab, EFI_BOOT_SERVICES::FreePool, EFI_BOOT_SERVICES::LocateHandleBuffer, method, NULL, rc, and strerror().

Referenced by efi_driver_connect_all(), efi_driver_disconnect_all(), and efi_driver_reconnect_all().

                                                                         {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_HANDLE *handles;
        UINTN num_handles;
        EFI_STATUS efirc;
        UINTN i;
        int rc;

        /* Enumerate all handles */
        if ( ( efirc = bs->LocateHandleBuffer ( AllHandles, NULL, NULL,
                                                &num_handles,
                                                &handles ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( &efi_driver_binding, "EFIDRV could not list handles: "
                       "%s\n", strerror ( rc ) );
                goto err_locate;
        }

        /* Connect/disconnect driver from all handles */
        for ( i = 0 ; i < num_handles ; i++ ) {
                if ( ( rc = method ( handles[i] ) ) != 0 ) {
                        /* Ignore errors and continue to process
                         * remaining handles.
                         */
                }
        }

        /* Success */
        rc = 0;

        bs->FreePool ( handles );
 err_locate:
        return rc;
}
int efi_driver_connect_all ( void  )

Connect EFI driver to all possible devices.

Return values:
rcReturn status code

Definition at line 548 of file efi_driver.c.

References DBGC, efi_driver_connect(), and efi_driver_handles().

Referenced by efi_probe().

                                    {

        DBGC ( &efi_driver_binding, "EFIDRV connecting our drivers\n" );
        return efi_driver_handles ( efi_driver_connect );
}
void efi_driver_disconnect_all ( void  )

Disconnect EFI driver from all possible devices.

Return values:
rcReturn status code

Definition at line 559 of file efi_driver.c.

References DBGC, efi_driver_disconnect(), and efi_driver_handles().

Referenced by efi_remove(), and efi_unload().

                                        {

        DBGC ( &efi_driver_binding, "EFIDRV disconnecting our drivers\n" );
        efi_driver_handles ( efi_driver_disconnect );
}
void efi_driver_reconnect_all ( void  )

Reconnect original EFI drivers to all possible devices.

Return values:
rcReturn status code

Definition at line 570 of file efi_driver.c.

References DBGC, efi_driver_handles(), and efi_driver_reconnect().

Referenced by _efi_start().

                                       {

        DBGC ( &efi_driver_binding, "EFIDRV reconnecting old drivers\n" );
        efi_driver_handles ( efi_driver_reconnect );
}

Variable Documentation

Initial value:
 {
        .Supported = efi_driver_supported,
        .Start = efi_driver_start,
        .Stop = efi_driver_stop,
}

EFI driver binding protocol.

Definition at line 42 of file efi_driver.c.

We are currently disconnecting drivers.

Definition at line 48 of file efi_driver.c.

Referenced by efi_driver_connect(), efi_driver_disconnect(), and efi_driver_start().

Initial value:
 {
        .GetDriverName = efi_driver_name,
        .GetControllerName = efi_driver_controller_name,
        .SupportedLanguages = "en",
}

EFI component name protocol.

Definition at line 358 of file efi_driver.c.