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.

Macros
#define	EINFO_EEFI_CONNECT
#define	EINFO_EEFI_CONNECT_PROHIBITED
#define	EEFI_CONNECT_PROHIBITED   __einfo_error ( EINFO_EEFI_CONNECT_PROHIBITED )
#define	EEFI_CONNECT(efirc)

Functions
	FILE_LICENCE (GPL2_OR_LATER)
static	LIST_HEAD (efi_devices)
	List of controlled EFI devices. More...
struct efi_device *	efidev_alloc (EFI_HANDLE device)
	Allocate new EFI device. More...
void	efidev_free (struct efi_device *efidev)
	Free EFI device. More...
static struct efi_device *	efidev_find (EFI_HANDLE device)
	Find EFI device. More...
struct efi_device *	efidev_parent (struct device *dev)
	Get parent EFI device. More...
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. More...
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. More...
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. More...
static EFI_STATUS EFIAPI	efi_driver_name (EFI_COMPONENT_NAME2_PROTOCOL *wtf __unused, CHAR8 *language __unused, CHAR16 **driver_name)
	Look up driver name. More...
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. More...
int	efi_driver_install (void)
	Install EFI driver. More...
void	efi_driver_uninstall (void)
	Uninstall EFI driver. More...
static int	efi_driver_connect (EFI_HANDLE device)
	Try to connect EFI driver. More...
static int	efi_driver_disconnect (EFI_HANDLE device)
	Try to disconnect EFI driver. More...
static int	efi_driver_reconnect (EFI_HANDLE device)
	Reconnect original EFI driver. More...
static int	efi_driver_handles (int(*method)(EFI_HANDLE handle))
	Connect/disconnect EFI driver from all handles. More...
int	efi_driver_connect_all (void)
	Connect EFI driver to all possible devices. More...
void	efi_driver_disconnect_all (void)
	Disconnect EFI driver from all possible devices. More...
void	efi_driver_reconnect_all (void)
	Reconnect original EFI drivers to all possible devices. More...

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

Detailed Description

EFI driver interface.

Definition in file efi_driver.c.

Macro Definition Documentation

EINFO_EEFI_CONNECT

#define EINFO_EEFI_CONNECT

Value:

__einfo_uniqify ( EINFO_EPLATFORM, 0x01,                        \
                          "Could not connect controllers" )

Definition at line 43 of file efi_driver.c.

EINFO_EEFI_CONNECT_PROHIBITED

#define EINFO_EEFI_CONNECT_PROHIBITED

Value:

__einfo_platformify ( EINFO_EEFI_CONNECT,                       \
                              EFI_SECURITY_VIOLATION,                   \
                              "Connecting controllers prohibited by "   \
                              "security policy" )

Definition at line 46 of file efi_driver.c.

EEFI_CONNECT_PROHIBITED

#define EEFI_CONNECT_PROHIBITED   __einfo_error ( EINFO_EEFI_CONNECT_PROHIBITED )

Definition at line 51 of file efi_driver.c.

EEFI_CONNECT

#define EEFI_CONNECT

(

efirc

)

Value:

EPLATFORM ( EINFO_EEFI_CONNECT, efirc,  \
                                          EEFI_CONNECT_PROHIBITED )

Definition at line 53 of file efi_driver.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER

)

LIST_HEAD()

static 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 70 of file efi_driver.c.

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

        /* 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_path_len ( path.path ) + sizeof ( *path_end ) );

        /* Allocate and initialise structure */
        efidev = zalloc ( sizeof ( *efidev ) + path_len );
        if ( ! efidev )
                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 );

 err_alloc:
        bs->CloseProtocol ( device, &efi_device_path_protocol_guid,
                            efi_image_handle, device );
 err_open_path:
        return efidev;
}

References EFI_SYSTEM_TABLE::BootServices, device_description::bus_type, BUS_TYPE_EFI, device::children, EFI_BOOT_SERVICES::CloseProtocol, DBGC, device::desc, efi_device::dev, efi_device::device, device, EEFI, efi_device_path_protocol_guid, efi_handle_name(), efi_image_handle, EFI_OPEN_PROTOCOL_GET_PROTOCOL, efi_path_len(), efi_systab, INIT_LIST_HEAD, list_add, memcpy(), NULL, EFI_BOOT_SERVICES::OpenProtocol, 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 118 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()

static 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 131 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, 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 155 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_ib_srp_path(), efi_netdev_path(), efi_snp_probe(), and efi_usb_path().

efi_driver_supported()

static 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 180 of file efi_driver.c.

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

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().

efi_driver_start()

static 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 221 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 DBGC, DBGCP, efi_device::driver, EFI_ALREADY_STARTED, efi_devpath_text(), efi_driver_disconnecting, EFI_DRIVERS, 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()

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

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 303 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 EFI_DEVICE_ERROR;
        }

        /* 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 assert(), children, DBGC, DBGCP, efi_device::driver, EFI_DEVICE_ERROR, efi_handle_name(), efi_raise_tpl(), efi_restore_tpl(), efidev_find(), efidev_free(), NULL, and efi_driver::stop.

efi_driver_name()

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

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

Return values

efirc

EFI status code

Definition at line 355 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 build_wname, name, and product_wname.

efi_driver_controller_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  )

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 375 of file efi_driver.c.

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

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_driver_install()

int efi_driver_install

(

void

)

Install EFI driver.

Return values

rc	Return status code

Definition at line 414 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 EFI_SYSTEM_TABLE::BootServices, build_timestamp, DBGC, _EFI_DRIVER_BINDING_PROTOCOL::DriverBindingHandle, EEFI, efi_component_name2_protocol_guid, efi_driver_binding, efi_driver_binding_protocol_guid, efi_image_handle, efi_systab, efi_wtf, _EFI_DRIVER_BINDING_PROTOCOL::ImageHandle, EFI_BOOT_SERVICES::InstallMultipleProtocolInterfaces, NULL, rc, strerror(), and _EFI_DRIVER_BINDING_PROTOCOL::Version.

Referenced by efi_init().

efi_driver_uninstall()

void efi_driver_uninstall

(

void

)

Uninstall EFI driver.

Definition at line 447 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_SYSTEM_TABLE::BootServices, 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_connect()

static 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 463 of file efi_driver.c.

                                                    {
        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,
                                               TRUE ) ) != 0 ) {
                rc = -EEFI_CONNECT ( efirc );
                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_CONNECT ( 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 EFI_SYSTEM_TABLE::BootServices, EFI_BOOT_SERVICES::ConnectController, DBGC, DBGC2, DBGC2_EFI_PROTOCOLS, EFI_BOOT_SERVICES::DisconnectController, _EFI_DRIVER_BINDING_PROTOCOL::DriverBindingHandle, EEFI, EEFI_CONNECT, efi_driver_binding, efi_driver_disconnecting, efi_driver_start(), efi_driver_supported(), efi_handle_name(), efi_systab, NULL, rc, strerror(), and TRUE.

Referenced by efi_driver_connect_all().

efi_driver_disconnect()

static 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 529 of file efi_driver.c.

                                                       {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;

        /* Disconnect our driver */
        efi_driver_disconnecting = 1;
        bs->DisconnectController ( device,
                                   efi_driver_binding.DriverBindingHandle,
                                   NULL );
        efi_driver_disconnecting = 0;
        return 0;
}

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

Referenced by efi_driver_disconnect_all().

efi_driver_reconnect()

static 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 547 of file efi_driver.c.

                                                      {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;

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

        return 0;
}

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

Referenced by efi_driver_reconnect_all().

efi_driver_handles()

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

static

Connect/disconnect EFI driver from all handles.

Parameters

method

Connect/disconnect method

Return values

rc	Return status code

Definition at line 562 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, EFI_SYSTEM_TABLE::BootServices, DBGC, EEFI, efi_driver_binding, 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_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 602 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 613 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(), 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 624 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(), and efi_image_exec().

Variable Documentation

efi_driver_binding

static 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 56 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 62 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 403 of file efi_driver.c.

Referenced by efi_driver_install(), and efi_driver_uninstall().