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_path.h>
#include <ipxe/efi/efi_driver.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER)
	FILE_SECBOOT (PERMITTED)
static	LIST_HEAD (efi_devices)
	List of controlled EFI devices.
struct efi_device *	efidev_alloc (EFI_HANDLE device)
	Allocate new EFI device.
void	efidev_free (struct efi_device *efidev)
	Free EFI device.
static struct efi_device *	efidev_find (EFI_HANDLE device)
	Find EFI device.
struct efi_device *	efidev_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.
int	efi_driver_exclude (EFI_HANDLE device, EFI_GUID *protocol)
	Try to disconnect an existing 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()

FILE_LICENCE

(

GPL2_OR_LATER

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

LIST_HEAD()

LIST_HEAD ( efi_devices )

static

List of controlled EFI devices.

efidev_alloc()

struct efi_device * efidev_alloc

(

EFI_HANDLE

device

)

Allocate new EFI device.

Parameters

device

EFI device handle

Return values

efidev

EFI device, or NULL on error

Definition at line 57 of file efi_driver.c.

                                                       {
        struct efi_device *efidev = NULL;
        EFI_DEVICE_PATH_PROTOCOL *path;
        EFI_DEVICE_PATH_PROTOCOL *path_end;
        size_t path_len;
        int rc;
 
        /* Open device path */
        if ( ( rc = efi_open ( device, &efi_device_path_protocol_guid,
                               &path ) ) != 0 ) {
                DBGC ( device, "EFIDRV %s could not open device path: %s\n",
                       efi_handle_name ( device ), strerror ( rc ) );
                return NULL;
        }
        path_len = ( efi_path_len ( path ) + sizeof ( *path_end ) );
 
        /* Allocate and initialise structure */
        efidev = zalloc ( sizeof ( *efidev ) + path_len );
        if ( ! efidev )
                return NULL;
        efidev->device = device;
        efidev->dev.desc.bus_type = BUS_TYPE_EFI;
        efidev->path = ( ( ( void * ) efidev ) + sizeof ( *efidev ) );
        memcpy ( efidev->path, path, path_len );
        INIT_LIST_HEAD ( &efidev->dev.children );
        list_add ( &efidev->dev.siblings, &efi_devices );
 
        return efidev;
}

References device_description::bus_type, BUS_TYPE_EFI, device::children, DBGC, device::desc, efi_device::dev, efi_device::device, efi_device_path_protocol_guid, EFI_HANDLE, efi_handle_name(), efi_open, efi_path_len(), INIT_LIST_HEAD, list_add, memcpy(), NULL, efi_device::path, rc, device::siblings, strerror(), and zalloc().

Referenced by efi_driver_start(), and mnptemp_create().

efidev_free()

void efidev_free

(

struct efi_device *

efidev

)

Free EFI device.

Parameters

efidev

EFI device

Definition at line 92 of file efi_driver.c.

                                               {
 
        assert ( list_empty ( &efidev->dev.children ) );
        list_del ( &efidev->dev.siblings );
        free ( efidev );
}

References assert, device::children, efi_device::dev, free, list_del, list_empty, and device::siblings.

Referenced by efi_driver_start(), efi_driver_stop(), mnptemp_create(), and mnptemp_destroy().

efidev_find()

struct efi_device * efidev_find ( EFI_HANDLE device )

static

Find EFI device.

Parameters

device

EFI device handle (or child handle)

Return values

efidev

EFI device, or NULL if not found

Definition at line 105 of file efi_driver.c.

                                                             {
        struct efi_device *efidev;
 
        /* Avoid false positive matches against NULL children */
        if ( ! device )
                return NULL;
 
        /* Look for an existing EFI device */
        list_for_each_entry ( efidev, &efi_devices, dev.siblings ) {
                if ( ( device == efidev->device ) ||
                     ( device == efidev->child ) ) {
                        return efidev;
                }
        }
 
        return NULL;
}

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

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

efidev_parent()

struct efi_device * efidev_parent

(

struct device *

dev

)

Get parent EFI device.

Parameters

dev	Generic device

Return values

efidev

Parent EFI device, or NULL

Definition at line 129 of file efi_driver.c.

                                                         {
        struct device *parent;
        struct efi_device *efidev;
 
        /* Walk upwards until we find a registered EFI device */
        while ( ( parent = dev->parent ) ) {
                list_for_each_entry ( efidev, &efi_devices, dev.siblings ) {
                        if ( parent == &efidev->dev )
                                return efidev;
                }
                dev = parent;
        }
 
        return NULL;
}

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

Referenced by efi_parent_path(), and efi_snp_probe().

efi_driver_supported()

EFI_STATUS EFIAPI efi_driver_supported ( EFI_DRIVER_BINDING_PROTOCOL *driver __unused, EFI_HANDLE device, EFI_DEVICE_PATH_PROTOCOL * child )

static

Check to see if driver supports a device.

Parameters

driver	EFI driver
device	EFI device
child	Path to child device, if any

Return values

efirc

EFI status code

Definition at line 154 of file efi_driver.c.

                                                                            {
        struct efi_driver *efidrv;
        unsigned int count;
        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;
        }
 
        /* Count drivers claiming to support this device */
        count = 0;
        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 );
                        count++;
                }
        }
 
        /* Check that we have at least one driver */
        if ( ! count ) {
                DBGCP ( device, "EFIDRV %s has no driver\n",
                        efi_handle_name ( device ) );
                return EFI_UNSUPPORTED;
        }
 
        return 0;
}

References __unused, count, DBGC, DBGCP, EFI_ALREADY_STARTED, efi_devpath_text(), EFI_DRIVERS, EFI_HANDLE, 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().

efi_driver_start()

EFI_STATUS EFIAPI efi_driver_start ( EFI_DRIVER_BINDING_PROTOCOL *driver __unused, EFI_HANDLE device, EFI_DEVICE_PATH_PROTOCOL * child )

static

Attach driver to device.

Parameters

driver	EFI driver
device	EFI device
child	Path to child device, if any

Return values

efirc

EFI status code

Definition at line 202 of file efi_driver.c.

                                                                        {
        struct efi_driver *efidrv;
        struct efi_device *efidev;
        struct efi_saved_tpl 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 */
        efi_raise_tpl ( &tpl );
 
        /* 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;
        }
 
        /* Add new device */
        efidev = efidev_alloc ( device );
        if ( ! efidev ) {
                efirc = EFI_OUT_OF_RESOURCES;
                goto err_alloc;
        }
 
        /* 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 );
                        efi_restore_tpl ( &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;
 
        efidev_free ( efidev );
 err_alloc:
 err_disconnecting:
        efi_restore_tpl ( &tpl );
 err_already_started:
        return efirc;
}

References __unused, DBGC, DBGCP, efi_device::driver, EFI_ALREADY_STARTED, efi_devpath_text(), efi_driver_disconnecting, EFI_DRIVERS, EFI_HANDLE, efi_handle_name(), EFI_NOT_READY, EFI_OUT_OF_RESOURCES, efi_raise_tpl(), efi_restore_tpl(), EFI_UNSUPPORTED, efidev_alloc(), efidev_find(), efidev_free(), for_each_table_entry, efi_driver::name, rc, efi_driver::start, strerror(), and efi_driver::supported.

Referenced by efi_driver_connect().

efi_driver_stop()

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

driver	EFI driver
device	EFI device
pci	PCI device
num_children	Number of child devices
children	List of child devices

Return values

efirc

EFI status code

Definition at line 284 of file efi_driver.c.

                                         {
        struct efi_driver *efidrv;
        struct efi_device *efidev;
        struct efi_saved_tpl 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 0;
        }
 
        /* Raise TPL */
        efi_raise_tpl ( &tpl );
 
        /* Stop this device */
        efidrv = efidev->driver;
        assert ( efidrv != NULL );
        efidrv->stop ( efidev );
        efidev_free ( efidev );
 
        efi_restore_tpl ( &tpl );
        return 0;
}

References __unused, assert, children, DBGC, DBGCP, efi_device::driver, EFI_HANDLE, efi_handle_name(), efi_raise_tpl(), efi_restore_tpl(), efidev_find(), efidev_free(), NULL, and efi_driver::stop.

efi_driver_name()

EFI_STATUS EFIAPI efi_driver_name ( EFI_COMPONENT_NAME2_PROTOCOL *wtf __unused, CHAR8 *language __unused, CHAR16 ** driver_name )

static

Look up driver name.

Parameters

wtf	Component name protocol
language	Language to use
driver_name	Driver name to fill in

Return values

efirc

EFI status code

Definition at line 336 of file efi_driver.c.

                                                                   {
        const wchar_t *name;
 
        name = ( product_wname[0] ? product_wname : build_wname );
        *driver_name = ( ( wchar_t * ) name );
        return 0;
}

References __unused, build_wname, name, product_wname, and wtf.

efi_driver_controller_name()

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

wtf	Component name protocol
device	Device
child	Child device, or NULL
language	Language to use
driver_name	Device name to fill in

Return values

efirc

EFI status code

Definition at line 356 of file efi_driver.c.

                                                                         {
        EFI_COMPONENT_NAME2_PROTOCOL *name2;
        int rc;
 
        /* Delegate to the EFI_COMPONENT_NAME2_PROTOCOL instance
         * installed on child handle, if present.
         */
        if ( ( child != NULL ) &&
             ( ( rc = efi_open ( child, &efi_component_name2_protocol_guid,
                                 &name2 ) ) == 0 ) ) {
                return name2->GetControllerName ( name2, device, child,
                                                  language, controller_name );
        }
 
        /* Otherwise, let EFI use the default Device Path Name */
        return EFI_UNSUPPORTED;
}

References __unused, efi_component_name2_protocol_guid, EFI_HANDLE, efi_open, EFI_UNSUPPORTED, _EFI_COMPONENT_NAME2_PROTOCOL::GetControllerName, NULL, rc, and wtf.

efi_driver_install()

int efi_driver_install

(

void

)

Install EFI driver.

Return values

rc	Return status code

Definition at line 388 of file efi_driver.c.

                                {
        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;
}

References build_timestamp, DBGC, EEFI, efi_component_name2_protocol_guid, efi_driver_binding, efi_driver_binding_protocol_guid, efi_image_handle, efi_systab, efi_wtf, EFI_BOOT_SERVICES::InstallMultipleProtocolInterfaces, NULL, rc, and strerror().

Referenced by efi_init().

efi_driver_uninstall()

void efi_driver_uninstall

(

void

)

Uninstall EFI driver.

Definition at line 421 of file efi_driver.c.

                                   {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
 
        /* Uninstall protocols */
        bs->UninstallMultipleProtocolInterfaces (
                efi_image_handle,
                &efi_driver_binding_protocol_guid, &efi_driver_binding,
                &efi_component_name2_protocol_guid, &efi_wtf, NULL );
}

References efi_component_name2_protocol_guid, efi_driver_binding, efi_driver_binding_protocol_guid, efi_image_handle, efi_systab, efi_wtf, NULL, and EFI_BOOT_SERVICES::UninstallMultipleProtocolInterfaces.

Referenced by efi_init(), and efi_unload().

efi_driver_exclude()

int efi_driver_exclude	(	EFI_HANDLE	device,
		EFI_GUID *	protocol )

Try to disconnect an existing EFI driver.

Parameters

device	EFI device
protocol	Protocol GUID

Return values

rc	Return status code

Definition at line 438 of file efi_driver.c.

                                                                 {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *openers;
        EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *opener;
        EFI_HANDLE driver;
        UINTN count;
        unsigned int i;
        EFI_STATUS efirc;
        int rc;
 
        /* Retrieve list of openers */
        if ( ( efirc = bs->OpenProtocolInformation ( device, protocol, &openers,
                                                     &count ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( device, "EFIDRV %s could not list %s openers: %s\n",
                       efi_handle_name ( device ), efi_guid_ntoa ( protocol ),
                       strerror ( rc ) );
                goto err_list;
        }
 
        /* Identify BY_DRIVER opener */
        driver = NULL;
        for ( i = 0 ; i < count ; i++ ) {
                opener = &openers[i];
                if ( opener->Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER ) {
                        driver = opener->AgentHandle;
                        break;
                }
        }
 
        /* Try to disconnect driver */
        DBGC ( device, "EFIDRV %s disconnecting %s drivers\n",
               efi_handle_name ( device ), efi_guid_ntoa ( protocol ) );
        if ( driver ) {
                DBGC ( device, "EFIDRV %s disconnecting %s driver ",
                       efi_handle_name ( device ), efi_guid_ntoa ( protocol ) );
                DBGC ( device, "%s\n", efi_handle_name ( driver ) );
                if ( ( rc = efi_disconnect ( device, driver ) ) != 0 ) {
                        DBGC ( device, "EFIDRV %s could not disconnect ",
                               efi_handle_name ( device ) );
                        DBGC ( device, "%s: %s\n",
                               efi_handle_name ( driver ), strerror ( rc ) );
                        goto err_disconnect;
                }
        }
 
        /* Success */
        rc = 0;
 
 err_disconnect:
        bs->FreePool ( openers );
 err_list:
        return rc;
}

References EFI_OPEN_PROTOCOL_INFORMATION_ENTRY::AgentHandle, EFI_OPEN_PROTOCOL_INFORMATION_ENTRY::Attributes, count, DBGC, EEFI, efi_disconnect(), efi_guid_ntoa(), EFI_HANDLE, efi_handle_name(), EFI_OPEN_PROTOCOL_BY_DRIVER, efi_systab, EFI_BOOT_SERVICES::FreePool, NULL, EFI_BOOT_SERVICES::OpenProtocolInformation, protocol, rc, and strerror().

Referenced by efipci_exclude(), nii_exclude(), snpnet_exclude(), and usbio_exclude().

efi_driver_connect()

int efi_driver_connect ( EFI_HANDLE device )

static

Try to connect EFI driver.

Parameters

device

EFI device

Return values

rc	Return status code

Definition at line 499 of file efi_driver.c.

                                                    {
        EFI_HANDLE driver = efi_driver_binding.DriverBindingHandle;
        struct efi_driver *efidrv;
        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;
        for_each_table_entry_reverse ( efidrv, EFI_DRIVERS ) {
                if ( ! efidrv->exclude )
                        continue;
                if ( ( rc = efidrv->supported ( device ) ) != 0 )
                        continue;
                if ( ( rc = efidrv->exclude ( device ) ) != 0 ) {
                        DBGC ( device, "EFIDRV %s could not disconnect "
                               "drivers: %s\n", efi_handle_name ( device ),
                               strerror ( rc ) );
                        /* Ignore the error and attempt to connect anyway */
                }
        }
        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 ( ( rc = efi_connect ( device, driver ) ) != 0 ) {
                DBGC ( device, "EFIDRV %s could not connect new drivers: "
                       "%s\n", efi_handle_name ( device ), strerror ( rc ) );
                DBGC ( device, "EFIDRV %s connecting driver directly\n",
                       efi_handle_name ( device ) );
                if ( ( efirc = efi_driver_start ( &efi_driver_binding, device,
                                                  NULL ) ) != 0 ) {
                        rc = -EEFI ( efirc );
                        DBGC ( device, "EFIDRV %s could not connect driver "
                               "directly: %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;
}

References DBGC, DBGC2, DBGC2_EFI_PROTOCOLS, EEFI, efi_connect(), efi_driver_binding, efi_driver_disconnecting, efi_driver_start(), efi_driver_supported(), EFI_DRIVERS, EFI_HANDLE, efi_handle_name(), efi_driver::exclude, for_each_table_entry_reverse, NULL, rc, strerror(), and efi_driver::supported.

Referenced by efi_driver_connect_all().

efi_driver_disconnect()

int efi_driver_disconnect ( EFI_HANDLE device )

static

Try to disconnect EFI driver.

Parameters

device

EFI device

Return values

rc	Return status code

Definition at line 566 of file efi_driver.c.

                                                       {
        EFI_HANDLE driver = efi_driver_binding.DriverBindingHandle;
 
        /* Disconnect our driver */
        efi_driver_disconnecting = 1;
        efi_disconnect ( device, driver );
        efi_driver_disconnecting = 0;
 
        return 0;
}

References efi_disconnect(), efi_driver_binding, efi_driver_disconnecting, and EFI_HANDLE.

Referenced by efi_driver_disconnect_all().

efi_driver_reconnect()

int efi_driver_reconnect ( EFI_HANDLE device )

static

Reconnect original EFI driver.

Parameters

device

EFI device

Return values

rc	Return status code

Definition at line 583 of file efi_driver.c.

                                                      {
 
        /* Reconnect any available driver */
        efi_connect ( device, NULL );
 
        return 0;
}

References efi_connect(), EFI_HANDLE, and NULL.

Referenced by efi_driver_reconnect_all().

efi_driver_handles()

int efi_driver_handles ( int(* method )(EFI_HANDLE handle) )

static

Connect/disconnect EFI driver from all handles.

Parameters

method

Connect/disconnect method

Return values

rc	Return status code

Definition at line 597 of file efi_driver.c.

                                                                         {
        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;
}

References AllHandles, DBGC, EEFI, efi_driver_binding, EFI_HANDLE, efi_systab, EFI_BOOT_SERVICES::FreePool, handle, 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_driver_connect_all()

int efi_driver_connect_all

(

void

)

Connect EFI driver to all possible devices.

Return values

rc	Return status code

Definition at line 637 of file efi_driver.c.

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

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

Referenced by efi_probe().

efi_driver_disconnect_all()

void efi_driver_disconnect_all

(

void

)

Disconnect EFI driver from all possible devices.

Return values

rc	Return status code

Definition at line 648 of file efi_driver.c.

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

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

Referenced by efi_remove(), efi_remove(), and efi_unload().

efi_driver_reconnect_all()

void efi_driver_reconnect_all

(

void

)

Reconnect original EFI drivers to all possible devices.

Return values

rc	Return status code

Definition at line 659 of file efi_driver.c.

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

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

Referenced by _efi_start(), efi_block_boot(), and efi_image_exec().

Variable Documentation

efi_driver_binding

EFI_DRIVER_BINDING_PROTOCOL efi_driver_binding

static

Initial value:

= {
        .Supported = efi_driver_supported,
        .Start = efi_driver_start,
        .Stop = efi_driver_stop,
}

EFI driver binding protocol.

Definition at line 43 of file efi_driver.c.

Referenced by efi_driver_connect(), efi_driver_connect_all(), efi_driver_disconnect(), efi_driver_disconnect_all(), efi_driver_handles(), efi_driver_install(), efi_driver_reconnect_all(), and efi_driver_uninstall().

efi_driver_disconnecting

int efi_driver_disconnecting

static

We are currently disconnecting drivers.

Definition at line 49 of file efi_driver.c.

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

efi_wtf

EFI_COMPONENT_NAME2_PROTOCOL efi_wtf

static

Initial value:

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

EFI component name protocol.

Definition at line 377 of file efi_driver.c.

                                              {
        .GetDriverName = efi_driver_name,
        .GetControllerName = efi_driver_controller_name,
        .SupportedLanguages = "en",
};

Referenced by efi_driver_install(), and efi_driver_uninstall().