[efi] Allow network devices to be created on top of arbitrary SNP devices

Signed-off-by: Michael Brown <mcb30@ipxe.org>

src/drivers/net/efi/snp.c

+/*
+ * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER );
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <ipxe/efi/efi.h>
+#include <ipxe/efi/Protocol/SimpleNetwork.h>
+#include <ipxe/efi/efi_driver.h>
+#include <ipxe/efi/efi_snp.h>
+#include <ipxe/efi/efi_pci.h>
+#include "snpnet.h"
+#include "snp.h"
+
+/** @file
+ *
+ * SNP driver
+ *
+ */
+
+/** EFI simple network protocol GUID */
+static EFI_GUID efi_simple_network_protocol_guid
+	= EFI_SIMPLE_NETWORK_PROTOCOL_GUID;
+
+/** EFI PCI I/O protocol GUID */
+static EFI_GUID efi_pci_io_protocol_guid
+	= EFI_PCI_IO_PROTOCOL_GUID;
+
+/**
+ * Check to see if driver supports a device
+ *
+ * @v device		EFI device handle
+ * @ret rc		Return status code
+ */
+static int snp_supported ( EFI_HANDLE device ) {
+	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
+	EFI_STATUS efirc;
+
+	/* Check that this is not a device we are providing ourselves */
+	if ( find_snpdev ( device ) != NULL ) {
+		DBGCP ( device, "SNP %p %s is provided by this binary\n",
+			device, efi_handle_devpath_text ( device ) );
+		return -ENOTTY;
+	}
+
+	/* Test for presence of simple network protocol */
+	if ( ( efirc = bs->OpenProtocol ( device,
+					  &efi_simple_network_protocol_guid,
+					  NULL, efi_image_handle, device,
+					  EFI_OPEN_PROTOCOL_TEST_PROTOCOL))!=0){
+		DBGCP ( device, "SNP %p %s is not an SNP device\n",
+			device, efi_handle_devpath_text ( device ) );
+		return -EEFI ( efirc );
+	}
+	DBGC ( device, "SNP %p %s is an SNP device\n",
+	       device, efi_handle_devpath_text ( device ) );
+
+	return 0;
+}
+
+/**
+ * Get underlying PCI device information
+ *
+ * @v snpdev		SNP device
+ * @ret rc		Return status code
+ */
+static int snp_pci_info ( struct snp_device *snpdev ) {
+	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
+	struct efi_device *efidev = snpdev->efidev;
+	EFI_DEVICE_PATH_PROTOCOL *devpath = efidev->path;
+	struct pci_device pci;
+	EFI_HANDLE device;
+	EFI_STATUS efirc;
+	int rc;
+
+	/* Check for presence of PCI I/O protocol */
+	if ( ( efirc = bs->LocateDevicePath ( &efi_pci_io_protocol_guid,
+					      &devpath, &device ) ) != 0 ) {
+		DBGC ( efidev->device, "SNP %p %s is not a PCI device\n",
+		       efidev->device, efi_devpath_text ( efidev->path ) );
+		return -EEFI ( efirc );
+	}
+
+	/* Get PCI device information */
+	if ( ( rc = efipci_info ( device, &pci ) ) != 0 ) {
+		DBGC ( efidev->device, "SNP %p %s could not get PCI "
+		       "information: %s\n", efidev->device,
+		       efi_devpath_text ( efidev->path ), strerror ( rc ) );
+		return rc;
+	}
+
+	/* Populate SNP device information */
+	memcpy ( &snpdev->dev.desc, &pci.dev.desc, sizeof ( snpdev->dev.desc ));
+	snprintf ( snpdev->dev.name, sizeof ( snpdev->dev.name ), "SNP-%s",
+		   pci.dev.name );
+
+	return 0;
+}
+
+/**
+ * Attach driver to device
+ *
+ * @v efidev		EFI device
+ * @ret rc		Return status code
+ */
+static int snp_start ( struct efi_device *efidev ) {
+	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
+	EFI_HANDLE device = efidev->device;
+	struct snp_device *snpdev;
+	union {
+		EFI_SIMPLE_NETWORK_PROTOCOL *snp;
+		void *interface;
+	} snp;
+	EFI_STATUS efirc;
+	int rc;
+
+	/* Check that this is not a device we are providing ourselves */
+	if ( find_snpdev ( efidev->device ) != NULL ) {
+		DBGCP ( device, "SNP %p %s is provided by this binary\n",
+			device, efi_devpath_text ( efidev->path ) );
+		rc = -ENOTTY;
+		goto err_own;
+	}
+
+	/* Allocate and initialise structure */
+	snpdev = zalloc ( sizeof ( *snpdev ) );
+	if ( ! snpdev ) {
+		rc = -ENOMEM;
+		goto err_alloc;
+	}
+	snpdev->efidev = efidev;
+	snpdev->dev.driver_name = "SNP";
+	INIT_LIST_HEAD ( &snpdev->dev.children );
+
+	/* See if device is an SNP device */
+	if ( ( efirc = bs->OpenProtocol ( device,
+					  &efi_simple_network_protocol_guid,
+					  &snp.interface, efi_image_handle,
+					  device,
+					  ( EFI_OPEN_PROTOCOL_BY_DRIVER |
+					    EFI_OPEN_PROTOCOL_EXCLUSIVE )))!=0){
+		rc = -EEFI ( efirc );
+		DBGCP ( device, "SNP %p %s cannot open SNP protocol: %s\n",
+			device, efi_devpath_text ( efidev->path ),
+			strerror ( rc ) );
+		goto err_open_protocol;
+	}
+	snpdev->snp = snp.snp;
+
+	/* Get underlying device information */
+	if ( ( rc = snp_pci_info ( snpdev ) ) != 0 )
+		goto err_info;
+
+	/* Mark SNP device as a child of the EFI device */
+	snpdev->dev.parent = &efidev->dev;
+	list_add ( &snpdev->dev.siblings, &efidev->dev.children );
+
+	/* Create SNP network device */
+	if ( ( rc = snpnet_probe ( snpdev ) ) != 0 )
+		goto err_probe;
+
+	efidev_set_drvdata ( efidev, snpdev );
+	return 0;
+
+	snpnet_remove ( snpdev );
+ err_probe:
+	list_del ( &snpdev->dev.siblings );
+ err_info:
+	bs->CloseProtocol ( device, &efi_simple_network_protocol_guid,
+			    efi_image_handle, device );
+ err_open_protocol:
+	free ( snpdev );
+ err_alloc:
+ err_own:
+	return rc;
+}
+
+/**
+ * Detach driver from device
+ *
+ * @v efidev		EFI device
+  */
+static void snp_stop ( struct efi_device *efidev ) {
+	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
+	struct snp_device *snpdev = efidev_get_drvdata ( efidev );
+
+	snpnet_remove ( snpdev );
+	list_del ( &snpdev->dev.siblings );
+	bs->CloseProtocol ( efidev->device, &efi_simple_network_protocol_guid,
+			    efi_image_handle, efidev->device );
+	free ( snpdev );
+}
+
+/** EFI SNP driver */
+struct efi_driver snp_driver __efi_driver ( EFI_DRIVER_NORMAL ) = {
+	.name = "SNP",
+	.supported = snp_supported,
+	.start = snp_start,
+	.stop = snp_stop,
+};

src/drivers/net/efi/snp.h

 FILE_LICENCE ( GPL2_OR_LATER );
 
 #include <ipxe/device.h>
-#include <ipxe/netdevice.h>
+#include <ipxe/efi/efi.h>
 #include <ipxe/efi/Protocol/SimpleNetwork.h>
 
-/** A network device that consumes the EFI Simple Network Protocol */
+/** An SNP device */
 struct snp_device {
-	/** Underlying simple network protocol instance */
+	/** EFI device */
+	struct efi_device *efidev;
+	/** Simple network protocol */
 	EFI_SIMPLE_NETWORK_PROTOCOL *snp;
-
 	/** Generic device */
 	struct device dev;
-
 	/** Network device */
 	struct net_device *netdev;
-
-	/** State to put the snp in when removing the device */
-	uint32 removal_state;
+	/** State to restore when removing the device */
+	UINT32 removal_state;
 };
 
 #endif /* _SNP_H */

src/include/ipxe/device.h

 /** TAP bus type */
 #define BUS_TYPE_TAP 6
 
+/** EFI bus type */
+#define BUS_TYPE_EFI 7
+
 /** A hardware device */
 struct device {
 	/** Name */

src/include/ipxe/efi/efi_driver.h

 
 FILE_LICENCE ( GPL2_OR_LATER );
 
+#include <ipxe/device.h>
 #include <ipxe/tables.h>
 #include <ipxe/efi/efi.h>
 #include <ipxe/efi/Protocol/DevicePath.h>
 
+/** An EFI device */
+struct efi_device {
+	/** Generic device */
+	struct device dev;
+	/** EFI device handle */
+	EFI_HANDLE device;
+	/** Device path */
+	EFI_DEVICE_PATH_PROTOCOL *path;
+	/** Driver for this device */
+	struct efi_driver *driver;
+	/** Driver-private data */
+	void *priv;
+};
+
 /** An EFI driver */
 struct efi_driver {
 	/** Name */
 	/**
 	 * Check if driver supports device
 	 *
-	 * @v device		Device
+	 * @v device		EFI device handle
 	 * @ret rc		Return status code
 	 */
 	int ( * supported ) ( EFI_HANDLE device );
 	/**
 	 * Attach driver to device
 	 *
-	 * @v device		Device
+	 * @v efidev		EFI device
 	 * @ret rc		Return status code
 	 */
-	int ( * start ) ( EFI_HANDLE device );
+	int ( * start ) ( struct efi_device *efidev );
 	/**
 	 * Detach driver from device
 	 *
-	 * @v device		Device
+	 * @v efidev		EFI device
 	 */
-	void ( * stop ) ( EFI_HANDLE device );
+	void ( * stop ) ( struct efi_device *efidev );
 };
 
 /** EFI driver table */
 #define EFI_DRIVER_NORMAL	02	/**< Normal drivers */
 #define EFI_DRIVER_LATE		03	/**< Late drivers */
 
+/**
+ * Set EFI driver-private data
+ *
+ * @v efidev		EFI device
+ * @v priv		Private data
+ */
+static inline void efidev_set_drvdata ( struct efi_device *efidev,
+					void *priv ) {
+	efidev->priv = priv;
+}
+
+/**
+ * Get EFI driver-private data
+ *
+ * @v efidev		EFI device
+ * @ret priv		Private data
+ */
+static inline void * efidev_get_drvdata ( struct efi_device *efidev ) {
+	return efidev->priv;
+}
+
 extern EFI_DEVICE_PATH_PROTOCOL *
 efi_devpath_end ( EFI_DEVICE_PATH_PROTOCOL *path );
+extern struct efi_device * efidev_parent ( struct device *dev );
+extern int efidev_child_add ( struct efi_device *efidev, EFI_HANDLE device );
+extern void efidev_child_del ( struct efi_device *efidev, EFI_HANDLE device );
 extern int efi_driver_install ( void );
 extern void efi_driver_uninstall ( void );
 extern int efi_driver_connect_all ( void );

src/include/ipxe/efi/efi_pci.h

 
 FILE_LICENCE ( GPL2_OR_LATER );
 
+#include <ipxe/pci.h>
 #include <ipxe/efi/efi.h>
 #include <ipxe/efi/Protocol/PciIo.h>
-#include <ipxe/efi/Protocol/DevicePath.h>
 
 /* PciRootBridgeIo.h uses LShiftU64(), which isn't defined anywhere else */
 static inline EFIAPI uint64_t LShiftU64 ( UINT64 value, UINTN shift ) {
 	return ( value << shift );
 }
 
-struct device;
-
-/** An EFI PCI device */
-struct efi_pci_device {
-	/** List of EFI PCI devices */
-	struct list_head list;
-	/** iPXE PCI device */
-	struct pci_device pci;
-	/** Underlying EFI device */
-	EFI_HANDLE device;
-	/** PCI I/O protocol */
-	EFI_PCI_IO_PROTOCOL *pci_io;
-	/** Device path */
-	EFI_DEVICE_PATH_PROTOCOL *path;
-};
-
-extern int efipci_create ( EFI_HANDLE device, UINT32 attributes,
-			   struct efi_pci_device **efipci );
-extern int efipci_enable ( struct efi_pci_device *efipci );
-extern struct efi_pci_device * efipci_find_efi ( EFI_HANDLE device );
-extern struct efi_pci_device * efipci_find ( struct device *dev );
-extern int efipci_child_add ( struct efi_pci_device *efipci,
-			      EFI_HANDLE device );
-extern void efipci_child_del ( struct efi_pci_device *efipci,
-			       EFI_HANDLE device );
-extern void efipci_destroy ( struct efi_pci_device *efipci );
+extern int efipci_open ( EFI_HANDLE device, UINT32 attributes,
+			 struct pci_device *pci );
+extern void efipci_close ( EFI_HANDLE device );
+extern int efipci_info ( EFI_HANDLE device, struct pci_device *pci );
 
 #endif /* _IPXE_EFI_PCI_H */

src/include/ipxe/efi/efi_snp.h

 	struct list_head list;
 	/** The underlying iPXE network device */
 	struct net_device *netdev;
-	/** The underlying EFI PCI device */
-	struct efi_pci_device *efipci;
+	/** The underlying EFI device */
+	struct efi_device *efidev;
 	/** EFI device handle */
 	EFI_HANDLE handle;
 	/** The SNP structure itself */
 
 extern int efi_snp_hii_install ( struct efi_snp_device *snpdev );
 extern void efi_snp_hii_uninstall ( struct efi_snp_device *snpdev );
+extern struct efi_snp_device * find_snpdev ( EFI_HANDLE handle );
 extern struct efi_snp_device * last_opened_snpdev ( void );
 extern void efi_snp_claim ( void );
 extern void efi_snp_release ( void );

src/include/ipxe/errfile.h

 #define ERRFILE_intel		     ( ERRFILE_DRIVER | 0x00650000 )
 #define ERRFILE_myson		     ( ERRFILE_DRIVER | 0x00660000 )
 #define ERRFILE_intelx		     ( ERRFILE_DRIVER | 0x00670000 )
+#define ERRFILE_snp		     ( ERRFILE_DRIVER | 0x00680000 )
 
 #define ERRFILE_scsi		     ( ERRFILE_DRIVER | 0x00700000 )
 #define ERRFILE_arbel		     ( ERRFILE_DRIVER | 0x00710000 )

src/interface/efi/efi_bofm.c

 /**
  * Check if device is supported
  *
- * @v device		EFI device
+ * @v device		EFI device handle
  * @ret rc		Return status code
  */
 static int efi_bofm_supported ( EFI_HANDLE device ) {
 	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
+	struct pci_device pci;
 	union {
 		IBM_BOFM_DRIVER_CONFIGURATION_PROTOCOL *bofm1;
 		void *interface;
 	} bofm1;
-	struct efi_pci_device *efipci;
 	EFI_STATUS efirc;
 	int rc;
 
-	/* Do nothing if we are already driving this device */
-	efipci = efipci_find_efi ( device );
-	if ( efipci ) {
-		DBGCP ( device, "EFIBOFM %p %s already started\n",
-			device, efi_devpath_text ( efipci->path ) );
-		rc = -EALREADY;
-		goto err_already_started;
-	}
-
-	/* Create corresponding PCI device, if any */
-	if ( ( rc = efipci_create ( device, EFI_OPEN_PROTOCOL_GET_PROTOCOL,
-				    &efipci ) ) != 0 )
-		goto err_create;
+	/* Get PCI device information */
+	if ( ( rc = efipci_info ( device, &pci ) ) != 0 )
+		return rc;
 
 	/* Look for a BOFM driver */
-	if ( ( rc = bofm_find_driver ( &efipci->pci ) ) != 0 ) {
+	if ( ( rc = bofm_find_driver ( &pci ) ) != 0 ) {
 		DBGCP ( device, "EFIBOFM %p %s has no driver\n",
-			device, efi_devpath_text ( efipci->path ) );
-		goto err_no_driver;
+			device, efi_handle_devpath_text ( device ) );
+		return rc;
 	}
 
 	/* Locate BOFM protocol */
 					    &bofm1.interface ) ) != 0 ) {
 		rc = -EEFI ( efirc );
 		DBGC ( device, "EFIBOFM %p %s cannot find BOFM protocol\n",
-		       device, efi_devpath_text ( efipci->path ) );
-		goto err_not_bofm;
+		       device, efi_handle_devpath_text ( device ) );
+		return rc;
 	}
 
 	/* Register support for this device */
 						      0x02 /* Version */ ))!=0){
 		rc = -EEFI ( efirc );
 		DBGC ( device, "EFIBOFM %p %s could not register support: %s\n",
-		       device, efi_devpath_text ( efipci->path ),
+		       device, efi_handle_devpath_text ( device ),
 		       strerror ( rc ) );
-		goto err_cannot_register;
+		return rc;
 	}
 
-	DBGC ( device, "EFIBOFM %p %s has driver \"%s\"\n", device,
-	       efi_devpath_text ( efipci->path ), efipci->pci.id->name );
-
-	/* Destroy temporary PCI device */
-	efipci_destroy ( efipci );
-
+	DBGC ( device, "EFIBOFM %p %s has driver \"%s\"\n",
+	       device, efi_handle_devpath_text ( device ), pci.id->name );
 	return 0;
-
- err_cannot_register:
- err_not_bofm:
- err_no_driver:
-	efipci_destroy ( efipci );
- err_create:
- err_already_started:
-	return rc;
 }
 
 /**
  * Attach driver to device
  *
- * @v device		EFI device
+ * @v efidev		EFI device
  * @ret rc		Return status code
  */
-static int efi_bofm_start ( EFI_HANDLE device ) {
+static int efi_bofm_start ( struct efi_device *efidev ) {
 	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
+	EFI_HANDLE device = efidev->device;
 	union {
 		IBM_BOFM_DRIVER_CONFIGURATION_PROTOCOL *bofm1;
 		void *interface;
 		IBM_BOFM_DRIVER_CONFIGURATION_PROTOCOL2 *bofm2;
 		void *interface;
 	} bofm2;
-	struct efi_pci_device *efipci;
+	struct pci_device pci;
 	IBM_BOFM_TABLE *bofmtab;
 	IBM_BOFM_TABLE *bofmtab2;
 	int bofmrc;
 	EFI_STATUS efirc;
 	int rc;
 
-	/* Do nothing if we are already driving this device */
-	efipci = efipci_find_efi ( device );
-	if ( efipci ) {
-		DBGCP ( device, "EFIPCI %p %s already started\n",
-			device, efi_devpath_text ( efipci->path ) );
-		rc = -EALREADY;
-		goto err_already_started;
-	}
-
-	/* Create corresponding PCI device */
-	if ( ( rc = efipci_create ( device, EFI_OPEN_PROTOCOL_GET_PROTOCOL,
-				    &efipci ) ) != 0 )
-		goto err_create;
-
-	/* Enable PCI device */
-	if ( ( rc = efipci_enable ( efipci ) ) != 0 )
-		goto err_enable;
+	/* Open PCI device, if possible */
+	if ( ( rc = efipci_open ( device, EFI_OPEN_PROTOCOL_GET_PROTOCOL,
+				  &pci ) ) != 0 )
+		goto err_open;
 
 	/* Locate BOFM protocol */
 	if ( ( efirc = bs->LocateProtocol ( &bofm1_protocol_guid, NULL,
 					    &bofm1.interface ) ) != 0 ) {
 		rc = -EEFI ( efirc );
 		DBGC ( device, "EFIBOFM %p %s cannot find BOFM protocol\n",
-		       device, efi_devpath_text ( efipci->path ) );
+		       device, efi_devpath_text ( efidev->path ) );
 		goto err_locate_bofm;
 	}
 	bofmtab = &bofm1.bofm1->BofmTable;
 	DBGC ( device, "EFIBOFM %p %s found version 1 BOFM table at %p+%04x\n",
-	       device, efi_devpath_text ( efipci->path ), bofmtab,
+	       device, efi_devpath_text ( efidev->path ), bofmtab,
 	       bofmtab->Parameters.Length );
 
 	/* Locate BOFM2 protocol, if available */
 					    &bofm2.interface ) ) == 0 ) {
 		bofmtab2 = &bofm2.bofm2->BofmTable;
 		DBGC ( device, "EFIBOFM %p %s found version 2 BOFM table at "
-		       "%p+%04x\n", device, efi_devpath_text ( efipci->path ),
+		       "%p+%04x\n", device, efi_devpath_text ( efidev->path ),
 		       bofmtab2, bofmtab2->Parameters.Length );
 		assert ( bofm2.bofm2->RegisterSupport ==
 			 bofm1.bofm1->RegisterSupport );
 	} else {
 		DBGC ( device, "EFIBOFM %p %s cannot find BOFM2 protocol\n",
-		       device, efi_devpath_text ( efipci->path ) );
+		       device, efi_devpath_text ( efidev->path ) );
 		/* Not a fatal error; may be a BOFM1-only system */
 		bofmtab2 = NULL;
 	}
 
 	/* Process BOFM table */
 	DBGC2 ( device, "EFIBOFM %p %s version 1 before processing:\n",
-		device, efi_devpath_text ( efipci->path ) );
+		device, efi_devpath_text ( efidev->path ) );
 	DBGC2_HD ( device, bofmtab, bofmtab->Parameters.Length );
 	if ( bofmtab2 ) {
 		DBGC2 ( device, "EFIBOFM %p %s version 2 before processing:\n",
-			device, efi_devpath_text ( efipci->path ) );
+			device, efi_devpath_text ( efidev->path ) );
 		DBGC2_HD ( device, bofmtab2, bofmtab2->Parameters.Length );
 	}
-	bofmrc = bofm ( virt_to_user ( bofmtab2 ? bofmtab2 : bofmtab ),
-			&efipci->pci );
+	bofmrc = bofm ( virt_to_user ( bofmtab2 ? bofmtab2 : bofmtab ), &pci );
 	DBGC ( device, "EFIBOFM %p %s status %08x\n",
-	       device, efi_devpath_text ( efipci->path ), bofmrc );
+	       device, efi_devpath_text ( efidev->path ), bofmrc );
 	DBGC2 ( device, "EFIBOFM %p %s version 1 after processing:\n",
-		device, efi_devpath_text ( efipci->path ) );
+		device, efi_devpath_text ( efidev->path ) );
 	DBGC2_HD ( device, bofmtab, bofmtab->Parameters.Length );
 	if ( bofmtab2 ) {
 		DBGC2 ( device, "EFIBOFM %p %s version 2 after processing:\n",
-			device, efi_devpath_text ( efipci->path ) );
+			device, efi_devpath_text ( efidev->path ) );
 		DBGC2_HD ( device, bofmtab2, bofmtab2->Parameters.Length );
 	}
 
 			rc = -EEFI ( efirc );
 			DBGC ( device, "EFIBOFM %p %s could not set BOFM2 "
 			       "status: %s\n",
-			       device, efi_devpath_text ( efipci->path ),
+			       device, efi_devpath_text ( efidev->path ),
 			       strerror ( rc ) );
 			goto err_set_status;
 		}
 			rc = -EEFI ( efirc );
 			DBGC ( device, "EFIBOFM %p %s could not set BOFM "
 			       "status: %s\n",
-			       device, efi_devpath_text ( efipci->path ),
+			       device, efi_devpath_text ( efidev->path ),
 			       strerror ( rc ) );
 			goto err_set_status;
 		}
 	}
 
-	/* Destroy the PCI device anyway; we have no further use for it */
-	efipci_destroy ( efipci );
-
 	/* BOFM (ab)uses the "start" method to mean "process and exit" */
-	return -EAGAIN;
+	rc = -EAGAIN;
 
  err_set_status:
  err_locate_bofm:
- err_enable:
-	efipci_destroy ( efipci );
- err_create:
- err_already_started:
+	efipci_close ( device );
+ err_open:
 	return rc;
 }
 
  *
  * @v device		EFI device
  */
-static void efi_bofm_stop ( EFI_HANDLE device __unused ) {
-	/* Nothing to do */
+static void efi_bofm_stop ( struct efi_device *efidev __unused ) {
+
+	/* Should never happen */
+	assert ( 0 );
 }
 
 /** EFI BOFM driver */

src/interface/efi/efi_driver.c

 FILE_LICENCE ( GPL2_OR_LATER );
 
 #include <stddef.h>
+#include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.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_driver.h>
 
 static EFI_GUID efi_component_name2_protocol_guid
 	= EFI_COMPONENT_NAME2_PROTOCOL_GUID;
 
+/** EFI device path protocol GUID */
+static EFI_GUID efi_device_path_protocol_guid
+	= EFI_DEVICE_PATH_PROTOCOL_GUID;
+
+/** List of controlled EFI devices */
+static LIST_HEAD ( efi_devices );
+
 /**
  * Find end of device path
  *
 	return path;
 }
 
+/**
+ * Find EFI device
+ *
+ * @v device		EFI device handle
+ * @ret efidev		EFI device, or NULL if not found
+ */
+static struct efi_device * efidev_find ( EFI_HANDLE device ) {
+	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;
+}
+
+/**
+ * Get parent EFI device
+ *
+ * @v dev		Generic device
+ * @ret efidev		Parent EFI device, or NULL
+ */
+struct efi_device * efidev_parent ( struct device *dev ) {
+	struct device *parent = dev->parent;
+	struct efi_device *efidev;
+
+	/* Check that parent exists and is an EFI device */
+	if ( ! parent )
+		return NULL;
+	if ( parent->desc.bus_type != BUS_TYPE_EFI )
+		return NULL;
+
+	/* Get containing EFI device */
+	efidev = container_of ( parent, struct efi_device, dev );
+	return efidev;
+}
+
+/**
+ * Add EFI device as child of EFI device
+ *
+ * @v efidev		EFI device
+ * @v device		EFI child device handle
+ * @ret efirc		EFI status code
+ */
+int efidev_child_add ( struct efi_device *efidev, EFI_HANDLE device ) {
+	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
+	void *devpath;
+	EFI_STATUS efirc;
+	int rc;
+
+	/* Re-open the device path protocol */
+	if ( ( efirc = bs->OpenProtocol ( efidev->device,
+					  &efi_device_path_protocol_guid,
+					  &devpath,
+					  efi_image_handle, device,
+					  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+					  ) ) != 0 ) {
+		rc = -EEFI ( efirc );
+		DBGC ( efidev->device, "EFIDRV %p %s could not add child",
+		       efidev->device, efi_devpath_text ( efidev->path ) );
+		DBGC ( efidev->device, " %p %s: %s\n", device,
+		       efi_handle_devpath_text ( device ), strerror ( rc ) );
+		return rc;
+	}
+
+	DBGC2 ( efidev->device, "EFIDRV %p %s added child",
+		efidev->device, efi_devpath_text ( efidev->path ) );
+	DBGC2 ( efidev->device, " %p %s\n",
+		device, efi_handle_devpath_text ( device ) );
+	return 0;
+}
+
+/**
+ * Remove EFI device as child of EFI device
+ *
+ * @v efidev		EFI device
+ * @v device		EFI child device handle
+ * @ret efirc		EFI status code
+ */
+void efidev_child_del ( struct efi_device *efidev, EFI_HANDLE device ) {
+	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
+
+	bs->CloseProtocol ( efidev->device,
+			    &efi_device_path_protocol_guid,
+			    efi_image_handle, device );
+	DBGC2 ( efidev->device, "EFIDRV %p %s removed child",
+		efidev->device, efi_devpath_text ( efidev->path ) );
+	DBGC2 ( efidev->device, " %p %s\n",
+		device, efi_handle_devpath_text ( device ) );
+}
+
 /**
  * Check to see if driver supports a device
  *
 		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 %p %s is already started\n",
+			device, efi_handle_devpath_text ( 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 ) {
 static EFI_STATUS EFIAPI
 efi_driver_start ( EFI_DRIVER_BINDING_PROTOCOL *driver __unused,
 		   EFI_HANDLE device, EFI_DEVICE_PATH_PROTOCOL *child ) {
+	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
 	struct efi_driver *efidrv;
+	struct efi_device *efidev;
+	union {
+		EFI_DEVICE_PATH_PROTOCOL *devpath;
+		void *interface;
+	} devpath;
+	EFI_STATUS efirc;
 	int rc;
 
 	DBGC ( device, "EFIDRV %p %s DRIVER_START",
 		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 %p %s is already started\n",
+			device, efi_devpath_text ( efidev->path ) );
+		efirc = EFI_ALREADY_STARTED;
+		goto err_already_started;
+	}
+
+	/* Allocate and initialise structure */
+	efidev = zalloc ( sizeof ( *efidev ) );
+	if ( ! efidev ) {
+		efirc = EFI_OUT_OF_RESOURCES;
+		goto err_alloc;
+	}
+	efidev->device = device;
+	efidev->dev.desc.bus_type = BUS_TYPE_EFI;
+	INIT_LIST_HEAD ( &efidev->dev.children );
+	list_add ( &efidev->dev.siblings, &efi_devices );
+
+	/* Open device path protocol */
+	if ( ( efirc = bs->OpenProtocol ( device,
+					  &efi_device_path_protocol_guid,
+					  &devpath.interface,
+					  efi_image_handle, device,
+					  EFI_OPEN_PROTOCOL_BY_DRIVER ) ) != 0){
+		DBGCP ( device, "EFIDRV %p %s has no device path\n",
+			device, efi_handle_devpath_text ( device ) );
+		goto err_no_device_path;
+	}
+	efidev->path = devpath.devpath;
+
 	/* Try to start this device */
 	for_each_table_entry ( efidrv, EFI_DRIVERS ) {
-		if ( ( rc = efidrv->start ( device ) ) == 0 ) {
+		if ( ( rc = efidrv->start ( efidev ) ) == 0 ) {
+			efidev->driver = efidrv;
 			DBGC ( device, "EFIDRV %p %s using driver \"%s\"\n",
-			       device, efi_handle_devpath_text ( device ),
-			       efidrv->name );
+			       device, efi_devpath_text ( efidev->path ),
+			       efidev->driver->name );
 			return 0;
 		}
 		DBGC ( device, "EFIDRV %p %s could not start driver \"%s\": "
-		       "%s\n", device, efi_handle_devpath_text ( device ),
+		       "%s\n", device, efi_devpath_text ( efidev->path ),
 		       efidrv->name, strerror ( rc ) );
 	}
-
-	return EFI_UNSUPPORTED;
+	efirc = EFI_UNSUPPORTED;
+
+	bs->CloseProtocol ( device, &efi_device_path_protocol_guid,
+			    efi_image_handle, device );
+ err_no_device_path:
+	list_del ( &efidev->dev.siblings );
+	free ( efidev );
+ err_alloc:
+ err_already_started:
+	return efirc;
 }
 
 /**
 efi_driver_stop ( EFI_DRIVER_BINDING_PROTOCOL *driver __unused,
 		  EFI_HANDLE device, UINTN num_children,
 		  EFI_HANDLE *children ) {
+	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
 	struct efi_driver *efidrv;
+	struct efi_device *efidev;
 	UINTN i;
 
 	DBGC ( device, "EFIDRV %p %s DRIVER_STOP",
 	}
 	DBGC ( device, "\n" );
 
-	/* Try to stop this device */
-	for_each_table_entry ( efidrv, EFI_DRIVERS )
-		efidrv->stop ( device );
+	/* Do nothing unless we are driving this device */
+	efidev = efidev_find ( device );
+	if ( ! efidev ) {
+		DBGCP ( device, "EFIDRV %p %s is not started\n",
+			device, efi_devpath_text ( efidev->path ) );
+		return 0;
+	}
+
+	/* Stop this device */
+	efidrv = efidev->driver;
+	assert ( efidrv != NULL );
+	efidrv->stop ( efidev );
+	bs->CloseProtocol ( efidev->device, &efi_device_path_protocol_guid,
+			    efi_image_handle, efidev->device );
+	list_del ( &efidev->dev.siblings );
+	free ( efidev );
 
 	return 0;
 }

src/interface/efi/efi_pci.c

 /* Disambiguate the various error causes */
 #define EINFO_EEFI_PCI							\
 	__einfo_uniqify ( EINFO_EPLATFORM, 0x01,			\
-			  "Could not open PCI I/O protocols" )
+			  "Could not open PCI I/O protocol" )
 #define EINFO_EEFI_PCI_NOT_PCI						\
 	__einfo_platformify ( EINFO_EEFI_PCI, EFI_UNSUPPORTED,		\
 			      "Not a PCI device" )
 static EFI_GUID efi_pci_io_protocol_guid
 	= EFI_PCI_IO_PROTOCOL_GUID;
 
-/** EFI device path protocol GUID */
-static EFI_GUID efi_device_path_protocol_guid
-	= EFI_DEVICE_PATH_PROTOCOL_GUID;
-
-/** EFI PCI devices */
-static LIST_HEAD ( efi_pci_devices );
-
 /**
- * Create EFI PCI device
+ * Open EFI PCI device
  *
- * @v device		EFI device
+ * @v device		EFI device handle
  * @v attributes	Protocol opening attributes
- * @v efipci		EFI PCI device to fill in
+ * @v pci		PCI device to fill in
  * @ret rc		Return status code
  */
-int efipci_create ( EFI_HANDLE device, UINT32 attributes,
-		    struct efi_pci_device **efipci ) {
+int efipci_open ( EFI_HANDLE device, UINT32 attributes,
+		  struct pci_device *pci ) {
 	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
 	union {
 		EFI_PCI_IO_PROTOCOL *pci_io;
 		void *interface;
 	} pci_io;
-	union {
-		EFI_DEVICE_PATH_PROTOCOL *path;
-		void *interface;
-	} path;
 	UINTN pci_segment, pci_bus, pci_dev, pci_fn;
 	EFI_STATUS efirc;
 	int rc;
 
-	/* Allocate PCI device */
-	*efipci = zalloc ( sizeof ( **efipci ) );
-	if ( ! *efipci ) {
-		rc = -ENOMEM;
-		goto err_zalloc;
-	}
-	(*efipci)->device = device;
-
 	/* See if device is a PCI device */
-	if ( ( efirc = bs->OpenProtocol ( device,
-					  &efi_pci_io_protocol_guid,
-					  &pci_io.interface,
-					  efi_image_handle,
+	if ( ( efirc = bs->OpenProtocol ( device, &efi_pci_io_protocol_guid,
+					  &pci_io.interface, efi_image_handle,
 					  device, attributes ) ) != 0 ) {
 		rc = -EEFI_PCI ( efirc );
 		DBGCP ( device, "EFIPCI %p %s cannot open PCI protocols: %s\n",
 			strerror ( rc ) );
 		goto err_open_protocol;
 	}
-	(*efipci)->pci_io = pci_io.pci_io;
 
 	/* Get PCI bus:dev.fn address */
-	if ( ( efirc = pci_io.pci_io->GetLocation ( pci_io.pci_io,
-						    &pci_segment,
+	if ( ( efirc = pci_io.pci_io->GetLocation ( pci_io.pci_io, &pci_segment,
 						    &pci_bus, &pci_dev,
 						    &pci_fn ) ) != 0 ) {
 		rc = -EEFI ( efirc );
-		DBGC ( device, "EFIPCI %p %s could not get PCI location: "
-		       "%s\n", device, efi_handle_devpath_text ( device ),
+		DBGC ( device, "EFIPCI %p %s could not get PCI location: %s\n",
+		       device, efi_handle_devpath_text ( device ),
 		       strerror ( rc ) );
 		goto err_get_location;
 	}
 		( ( unsigned long ) pci_segment ), ( ( unsigned long ) pci_bus),
 		( ( unsigned long ) pci_dev ), ( ( unsigned long ) pci_fn ) );
 
+	/* Try to enable I/O cycles, memory cycles, and bus mastering.
+	 * Some platforms will 'helpfully' report errors if these bits
+	 * can't be enabled (for example, if the card doesn't actually
+	 * support I/O cycles).  Work around any such platforms by
+	 * enabling bits individually and simply ignoring any errors.
+	 */
+	pci_io.pci_io->Attributes ( pci_io.pci_io,
+				    EfiPciIoAttributeOperationEnable,
+				    EFI_PCI_IO_ATTRIBUTE_IO, NULL );
+	pci_io.pci_io->Attributes ( pci_io.pci_io,
+				    EfiPciIoAttributeOperationEnable,
+				    EFI_PCI_IO_ATTRIBUTE_MEMORY, NULL );
+	pci_io.pci_io->Attributes ( pci_io.pci_io,
+				    EfiPciIoAttributeOperationEnable,
+				    EFI_PCI_IO_ATTRIBUTE_BUS_MASTER, NULL );
+
 	/* Populate PCI device */
-	pci_init ( &(*efipci)->pci, PCI_BUSDEVFN ( pci_bus, pci_dev, pci_fn ) );
-	if ( ( rc = pci_read_config ( &(*efipci)->pci ) ) != 0 ) {
+	pci_init ( pci, PCI_BUSDEVFN ( pci_bus, pci_dev, pci_fn ) );
+	if ( ( rc = pci_read_config ( pci ) ) != 0 ) {
 		DBGC ( device, "EFIPCI %p %s cannot read PCI configuration: "
 		       "%s\n", device, efi_handle_devpath_text ( device ),
 		       strerror ( rc ) );
 		goto err_pci_read_config;
 	}
 
-	/* Retrieve device path */
-	if ( ( efirc = bs->OpenProtocol ( device,
-					  &efi_device_path_protocol_guid,
-					  &path.interface, efi_image_handle,
-					  device, attributes ) ) != 0 ) {
-		rc = -EEFI ( efirc );
-		DBGC ( device, "EFIPCI %p %s has no device path\n",
-		       device, efi_handle_devpath_text ( device ) );
-		goto err_no_device_path;
-	}
-	(*efipci)->path = path.path;
-
-	/* Add to list of PCI devices */
-	list_add ( &(*efipci)->list, &efi_pci_devices );
-
 	return 0;
 
-	bs->CloseProtocol ( device, &efi_device_path_protocol_guid,
-			    efi_image_handle, device );
- err_no_device_path:
  err_pci_read_config:
  err_get_location:
 	bs->CloseProtocol ( device, &efi_pci_io_protocol_guid,
 			    efi_image_handle, device );
  err_open_protocol:
-	free ( *efipci );
- err_zalloc:
 	return rc;
 }
 
 /**
- * Enable EFI PCI device
- *
- * @v efipci		EFI PCI device
- * @ret rc		Return status code
- */
-int efipci_enable ( struct efi_pci_device *efipci ) {
-	EFI_PCI_IO_PROTOCOL *pci_io = efipci->pci_io;
-
-	/* Try to enable I/O cycles, memory cycles, and bus mastering.
-	 * Some platforms will 'helpfully' report errors if these bits
-	 * can't be enabled (for example, if the card doesn't actually
-	 * support I/O cycles).  Work around any such platforms by
-	 * enabling bits individually and simply ignoring any errors.
-	 */
-	pci_io->Attributes ( pci_io, EfiPciIoAttributeOperationEnable,
-			     EFI_PCI_IO_ATTRIBUTE_IO, NULL );
-	pci_io->Attributes ( pci_io, EfiPciIoAttributeOperationEnable,
-			     EFI_PCI_IO_ATTRIBUTE_MEMORY, NULL );
-	pci_io->Attributes ( pci_io, EfiPciIoAttributeOperationEnable,
-			     EFI_PCI_IO_ATTRIBUTE_BUS_MASTER, NULL );
-
-	return 0;
-}
-
-/**
- * Find EFI PCI device by EFI device
- *
- * @v device		EFI device
- * @ret efipci		EFI PCI device, or NULL
- */
-struct efi_pci_device * efipci_find_efi ( EFI_HANDLE device ) {
-	struct efi_pci_device *efipci;
-
-	list_for_each_entry ( efipci, &efi_pci_devices, list ) {
-		if ( efipci->device == device )
-			return efipci;
-	}
-	return NULL;
-}
-
-/**
- * Find EFI PCI device by iPXE device
+ * Close EFI PCI device
  *
- * @v dev		Device
- * @ret efipci		EFI PCI device, or NULL
+ * @v device		EFI device handle
  */
-struct efi_pci_device * efipci_find ( struct device *dev ) {
-	struct efi_pci_device *efipci;
+void efipci_close ( EFI_HANDLE device ) {
+	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
 
-	list_for_each_entry ( efipci, &efi_pci_devices, list ) {
-		if ( &efipci->pci.dev == dev )
-			return efipci;
-	}
-	return NULL;
+	bs->CloseProtocol ( device, &efi_pci_io_protocol_guid,
+			    efi_image_handle, device );
 }
 
 /**
- * Add EFI device as child of EFI PCI device
+ * Get EFI PCI device information
  *
- * @v efipci		EFI PCI device
- * @v device		EFI child device
- * @ret efirc		EFI status code
+ * @v device		EFI device handle
+ * @v pci		PCI device to fill in
+ * @ret rc		Return status code
  */
-int efipci_child_add ( struct efi_pci_device *efipci, EFI_HANDLE device ) {
-	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
-	union {
-		EFI_PCI_IO_PROTOCOL *pci_io;
-		void *interface;
-	} pci_io;
-	EFI_STATUS efirc;
+int efipci_info ( EFI_HANDLE device, struct pci_device *pci ) {
 	int rc;
 
-	/* Re-open the PCI_IO_PROTOCOL */
-	if ( ( efirc = bs->OpenProtocol ( efipci->device,
-					  &efi_pci_io_protocol_guid,
-					  &pci_io.interface,
-					  efi_image_handle, device,
-					  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
-					  ) ) != 0 ) {
-		rc = -EEFI ( efirc );
-		DBGC ( efipci->device, "EFIPCI %p %s could not add child",
-		       efipci->device, efi_devpath_text ( efipci->path ) );
-		DBGC ( efipci->device, " %p %s: %s\n", device,
-		       efi_handle_devpath_text ( device ), strerror ( rc ) );
+	/* Open PCI device, if possible */
+	if ( ( rc = efipci_open ( device, EFI_OPEN_PROTOCOL_GET_PROTOCOL,
+				  pci ) ) != 0 )
 		return rc;
-	}
-
-	DBGC2 ( efipci->device, "EFIPCI %p %s added child",
-		efipci->device, efi_devpath_text ( efipci->path ) );
-	DBGC2 ( efipci->device, " %p %s\n",
-		device, efi_handle_devpath_text ( device ) );
-	return 0;
-}
-
-/**
- * Remove EFI device as child of PCI device
- *
- * @v efipci		EFI PCI device
- * @v device		EFI child device
- * @ret efirc		EFI status code
- */
-void efipci_child_del ( struct efi_pci_device *efipci, EFI_HANDLE device ) {
-	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
-
-	bs->CloseProtocol ( efipci->device, &efi_pci_io_protocol_guid,
-			    efi_image_handle, device );
-	DBGC2 ( efipci->device, "EFIPCI %p %s removed child",
-		efipci->device, efi_devpath_text ( efipci->path ) );
-	DBGC2 ( efipci->device, " %p %s\n",
-		device, efi_handle_devpath_text ( device ) );
-}
 
-/**
- * Destroy EFI PCI device
- *
- * @v efipci		EFI PCI device
- */
-void efipci_destroy ( struct efi_pci_device *efipci ) {
-	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
+	/* Close PCI device */
+	efipci_close ( device );
 
-	list_del ( &efipci->list );
-	bs->CloseProtocol ( efipci->device, &efi_device_path_protocol_guid,
-			    efi_image_handle, efipci->device );
-	bs->CloseProtocol ( efipci->device, &efi_pci_io_protocol_guid,
-			    efi_image_handle, efipci->device );
-	free ( efipci );
+	return 0;
 }
 
 /******************************************************************************
 /**
  * Check to see if driver supports a device
  *
- * @v device		EFI device
+ * @v device		EFI device handle
  * @ret rc		Return status code
  */
 static int efipci_supported ( EFI_HANDLE device ) {
-	struct efi_pci_device *efipci;
+	struct pci_device pci;
 	int rc;
 
-	/* Do nothing if we are already driving this device */
-	efipci = efipci_find_efi ( device );
-	if ( efipci ) {
-		DBGCP ( device, "EFIPCI %p %s already started\n",
-			device, efi_devpath_text ( efipci->path ) );
-		rc = -EALREADY;
-		goto err_already_started;
-	}
-
-	/* Create temporary corresponding PCI device, if any */
-	if ( ( rc = efipci_create ( device, EFI_OPEN_PROTOCOL_GET_PROTOCOL,
-				    &efipci ) ) != 0 )
-		goto err_create;
+	/* Get PCI device information */
+	if ( ( rc = efipci_info ( device, &pci ) ) != 0 )
+		return rc;
 
 	/* Look for a driver */
-	if ( ( rc = pci_find_driver ( &efipci->pci ) ) != 0 ) {
+	if ( ( rc = pci_find_driver ( &pci ) ) != 0 ) {
 		DBGCP ( device, "EFIPCI %p %s has no driver\n",
-			device, efi_devpath_text ( efipci->path ) );
-		goto err_no_driver;
+			device, efi_handle_devpath_text ( device ) );
+		return rc;
 	}
-
-	DBGC ( device, "EFIPCI %p %s has driver \"%s\"\n", device,
-	       efi_devpath_text ( efipci->path ), efipci->pci.id->name );
-
-	/* Destroy temporary PCI device */
-	efipci_destroy ( efipci );
+	DBGC ( device, "EFIPCI %p %s has driver \"%s\"\n",
+	       device, efi_handle_devpath_text ( device ), pci.id->name );
 
 	return 0;
-
- err_no_driver:
-	efipci_destroy ( efipci );
- err_create:
- err_already_started:
-	return rc;
 }
 
 /**
  * Attach driver to device
  *
- * @v device		EFI device
+ * @v efidev		EFI device
  * @ret rc		Return status code
  */
-static int efipci_start ( EFI_HANDLE device ) {
-	struct efi_pci_device *efipci;
+static int efipci_start ( struct efi_device *efidev ) {
+	EFI_HANDLE device = efidev->device;
+	struct pci_device *pci;
 	int rc;
 
-	/* Do nothing if we are already driving this device */
-	efipci = efipci_find_efi ( device );
-	if ( efipci ) {
-		DBGCP ( device, "EFIPCI %p %s already started\n",
-			device, efi_devpath_text ( efipci->path ) );
-		rc = -EALREADY;
-		goto err_already_started;
+	/* Allocate PCI device */
+	pci = zalloc ( sizeof ( *pci ) );
+	if ( ! pci ) {
+		rc = -ENOMEM;
+		goto err_alloc;
 	}
 
-	/* Create corresponding PCI device */
-	if ( ( rc = efipci_create ( device, ( EFI_OPEN_PROTOCOL_BY_DRIVER |
-					      EFI_OPEN_PROTOCOL_EXCLUSIVE ),
-				    &efipci ) ) != 0 )
-		goto err_create;
+	/* Open PCI device */
+	if ( ( rc = efipci_open ( device, ( EFI_OPEN_PROTOCOL_BY_DRIVER |
+					    EFI_OPEN_PROTOCOL_EXCLUSIVE ),
+				  pci ) ) != 0 ) {
+		DBGC ( device, "EFIPCI %p %s could not open PCI device: %s\n",
+		       device, efi_devpath_text ( efidev->path ),
+		       strerror ( rc ) );
+		goto err_open;
+	}
 
 	/* Find driver */
-	if ( ( rc = pci_find_driver ( &efipci->pci ) ) != 0 ) {
+	if ( ( rc = pci_find_driver ( pci ) ) != 0 ) {
 		DBGC ( device, "EFIPCI %p %s has no driver\n",
-		       device, efi_devpath_text ( efipci->path ) );
+		       device, efi_devpath_text ( efidev->path ) );
 		goto err_find_driver;
 	}
 
-	/* Enable PCI device */
-	if ( ( rc = efipci_enable ( efipci ) ) != 0 )
-		goto err_enable;
+	/* Mark PCI device as a child of the EFI device */
+	pci->dev.parent = &efidev->dev;
+	list_add ( &pci->dev.siblings, &efidev->dev.children );
 
 	/* Probe driver */
-	if ( ( rc = pci_probe ( &efipci->pci ) ) != 0 ) {
+	if ( ( rc = pci_probe ( pci ) ) != 0 ) {
 		DBGC ( device, "EFIPCI %p %s could not probe driver \"%s\": "
-		       "%s\n", device, efi_devpath_text ( efipci->path ),
-		       efipci->pci.id->name, strerror ( rc ) );
+		       "%s\n", device, efi_devpath_text ( efidev->path ),
+		       pci->id->name, strerror ( rc ) );
 		goto err_probe;
 	}
 	DBGC ( device, "EFIPCI %p %s using driver \"%s\"\n", device,
-	       efi_devpath_text ( efipci->path ), efipci->pci.id->name );
+	       efi_devpath_text ( efidev->path ), pci->id->name );
 
+	efidev_set_drvdata ( efidev, pci );
 	return 0;
 
-	pci_remove ( &efipci->pci );
+	pci_remove ( pci );
  err_probe:
- err_enable:
+	list_del ( &pci->dev.siblings );
  err_find_driver:
-	efipci_destroy ( efipci );
- err_create:
- err_already_started:
+	efipci_close ( device );
+ err_open:
+	free ( pci );
+ err_alloc:
 	return rc;
 }
 
 /**
  * Detach driver from device
  *
- * @v device		EFI device
+ * @v efidev		EFI device
   */
-static void efipci_stop ( EFI_HANDLE device ) {
-	struct efi_pci_device *efipci;
-
-	/* Find PCI device */
-	efipci = efipci_find_efi ( device );
-	if ( ! efipci )
-		return;
-
-	/* Remove device */
-	pci_remove ( &efipci->pci );
-
-	/* Delete EFI PCI device */
-	efipci_destroy ( efipci );
+static void efipci_stop ( struct efi_device *efidev ) {
+	struct pci_device *pci = efidev_get_drvdata ( efidev );
+	EFI_HANDLE device = efidev->device;
+
+	pci_remove ( pci );
+	list_del ( &pci->dev.siblings );
+	efipci_close ( device );
+	free ( pci );
 }
 
 /** EFI PCI driver */

src/interface/efi/efi_snp.c

 #include <ipxe/netdevice.h>
 #include <ipxe/iobuf.h>
 #include <ipxe/in.h>
-#include <ipxe/pci.h>
 #include <ipxe/version.h>
 #include <ipxe/efi/efi.h>
-#include <ipxe/efi/efi_pci.h>
 #include <ipxe/efi/efi_driver.h>
 #include <ipxe/efi/efi_strings.h>
 #include <ipxe/efi/efi_snp.h>
 	/* MAC address changes take effect only on netdev_open() */
 	if ( netdev_is_open ( snpdev->netdev ) ) {
 		DBGC ( snpdev, "SNPDEV %p MAC address changed while net "
-		       "devive open\n", snpdev );
+		       "device open\n", snpdev );
 	}
 
 	return 0;
  */
 static int efi_snp_probe ( struct net_device *netdev ) {
 	EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
-	struct efi_pci_device *efipci;
+	struct efi_device *efidev;
 	struct efi_snp_device *snpdev;
 	EFI_DEVICE_PATH_PROTOCOL *path_end;
 	MAC_ADDR_DEVICE_PATH *macpath;
 	EFI_STATUS efirc;
 	int rc;
 
-	/* Find EFI PCI device */
-	efipci = efipci_find ( netdev->dev );
-	if ( ! efipci ) {
-		DBG ( "SNP skipping non-PCI device %s\n", netdev->name );
+	/* Find parent EFI device */
+	efidev = efidev_parent ( netdev->dev );
+	if ( ! efidev ) {
+		DBG ( "SNP skipping non-EFI device %s\n", netdev->name );
 		rc = 0;
-		goto err_no_pci;
+		goto err_no_efidev;
 	}
 
 	/* Calculate device path prefix length */
-	path_end = efi_devpath_end ( efipci->path );
+	path_end = efi_devpath_end ( efidev->path );
 	path_prefix_len = ( ( ( void * ) path_end ) -
-			    ( ( void * ) efipci->path ) );
+			    ( ( void * ) efidev->path ) );
 
 	/* Allocate the SNP device */
 	snpdev = zalloc ( sizeof ( *snpdev ) + path_prefix_len +
 		goto err_alloc_snp;
 	}
 	snpdev->netdev = netdev_get ( netdev );
-	snpdev->efipci = efipci;
+	snpdev->efidev = efidev;
 
 	/* Sanity check */
 	if ( netdev->ll_protocol->ll_addr_len > sizeof ( EFI_MAC_ADDRESS ) ) {
 		       "%s", netdev->name );
 
 	/* Populate the device path */
-	memcpy ( &snpdev->path, efipci->path, path_prefix_len );
+	memcpy ( &snpdev->path, efidev->path, path_prefix_len );
 	macpath = ( ( ( void * ) &snpdev->path ) + path_prefix_len );
 	path_end = ( ( void * ) ( macpath + 1 ) );
 	memset ( macpath, 0, sizeof ( *macpath ) );
 		goto err_install_protocol_interface;
 	}
 
-	/* Add as child of PCI device */
-	if ( ( rc = efipci_child_add ( efipci, snpdev->handle ) ) != 0 ) {
-		DBGC ( snpdev, "SNPDEV %p could not become child of " PCI_FMT
-		       ": %s\n", snpdev, PCI_ARGS ( &efipci->pci ),
-		       strerror ( rc ) );
-		goto err_efipci_child_add;
+	/* Add as child of EFI parent device */
+	if ( ( rc = efidev_child_add ( efidev, snpdev->handle ) ) != 0 ) {
+		DBGC ( snpdev, "SNPDEV %p could not become child of %p %s: "
+		       "%s\n", snpdev, efidev->device,
+		       efi_devpath_text ( efidev->path ), strerror ( rc ) );
+		goto err_efidev_child_add;
 	}
 
 	/* Install HII */
 	/* Add to list of SNP devices */
 	list_add ( &snpdev->list, &efi_snp_devices );
 
-	DBGC ( snpdev, "SNPDEV %p installed for %s as device %p\n",
-	       snpdev, netdev->name, snpdev->handle );
+	DBGC ( snpdev, "SNPDEV %p installed for %s as device %p %s\n",
+	       snpdev, netdev->name, snpdev->handle,
+	       efi_devpath_text ( &snpdev->path ) );
 	return 0;
 
 	efi_snp_hii_uninstall ( snpdev );
  err_hii_install:
-	efipci_child_del ( efipci, snpdev->handle );
- err_efipci_child_add:
+	efidev_child_del ( efidev, snpdev->handle );
+ err_efidev_child_add:
 	bs->UninstallMultipleProtocolInterfaces (
 			snpdev->handle,
 			&efi_simple_network_protocol_guid, &snpdev->snp,
 	netdev_put ( netdev );
 	free ( snpdev );
  err_alloc_snp:
- err_no_pci:
+ err_no_efidev:
 	return rc;
 }
 
 
 	/* Uninstall the SNP */
 	efi_snp_hii_uninstall ( snpdev );
-	efipci_child_del ( snpdev->efipci, snpdev->handle );
+	efidev_child_del ( snpdev->efidev, snpdev->handle );
 	list_del ( &snpdev->list );
 	bs->UninstallMultipleProtocolInterfaces (
 			snpdev->handle,
 	.remove = efi_snp_remove,
 };
 
+/**
+ * Find SNP device by EFI device handle
+ *
+ * @v handle		EFI device handle
+ * @ret snpdev		SNP device, or NULL
+ */
+struct efi_snp_device * find_snpdev ( EFI_HANDLE handle ) {
+	struct efi_snp_device *snpdev;
+
+	list_for_each_entry ( snpdev, &efi_snp_devices, list ) {
+		if ( snpdev->handle == handle )
+			return snpdev;
+	}
+	return NULL;
+}
+
 /**
  * Get most recently opened SNP device
  *