Added back in the actual call to load().

src/core/main.c

 		/* Skip this device the next time we encounter it */
 		skip = 1;
 
-		/* Print out what we're doing */
-		printf ( "Booting from %s %s at %s "
-			 "using the %s driver\n",
+		/* Print out device information */
+		printf ( "%s (%s) %s at %s\n",
 			 dev.bus_driver->name_device ( &dev.bus_dev ),
+			 dev.device_driver->name,
 			 dev.type_driver->name,
-			 dev.bus_driver->describe_device ( &dev.bus_dev ),
-			 dev.device_driver->name );
+			 dev.bus_driver->describe_device ( &dev.bus_dev ) );
 
 		/* Probe boot device */
 		if ( ! probe ( &dev ) ) {
 			/* Device found on bus, but probe failed */
-			printf ( "...probe failed on %s\n" );
+			printf ( "...probe failed\n" );
 			continue;
 		}
-		
-		printf ( "%s: %s\n",
+
+		/* Print out device information */
+		printf ( "%s %s has %s\n",
 			 dev.bus_driver->name_device ( &dev.bus_dev ),
+			 dev.type_driver->name,
 			 dev.type_driver->describe_device ( dev.type_dev ) );
+
+		/* Configure boot device */
+		if ( ! configure ( &dev ) ) {
+			/* Configuration (e.g. DHCP) failed */
+			printf ( "...configuration failed\n" );
+			continue;
+		}
+
+		/* Boot from the device */
+		load ( &dev, load_block );
+
 	}
 
 	/* Call registered per-object exit functions */
 #endif
 };
 
-int loadkernel(const char *fname)
-{
+int loadkernel ( const char *fname,
+		 int ( * load_block ) ( unsigned char *data,
+					unsigned int blocknum,
+					unsigned int len, int eof ) ) {
 	static const struct proto * const last_proto = 
 		&protos[sizeof(protos)/sizeof(protos[0])];
 	const struct proto *proto;

src/core/nic.c

 /*
  * Find out what our boot parameters are
  */
-static int nic_load_configuration ( struct nic *nic ) {
+static int nic_configure ( struct type_dev *type_dev ) {
+	struct nic *nic = ( struct nic * ) type_dev;
 	int server_found;
 
 	if ( ! nic->nic_op->connect ( nic ) ) {
 		printf("No Server found\n");
 		return 0;
 	}
-	return 1;
-}
 
-
-/**************************************************************************
-LOAD - Try to get booted
-**************************************************************************/
-static int nic_load(struct dev *dev __unused)
-{
-	const char	*kernel;
 	printf("\nMe: %@", arptable[ARP_CLIENT].ipaddr.s_addr );
 #ifndef NO_DHCP_SUPPORT
 	printf(", DHCP: %@", dhcp_server );
 	printf("\n=>>"); getchar();
 #endif
 
+	return 1;
+}
+
+
+/**************************************************************************
+LOAD - Try to get booted
+**************************************************************************/
+static int nic_load ( struct type_dev *type_dev,
+		      int ( * process ) ( unsigned char *data,
+					  unsigned int blocknum,
+					  unsigned int size, int eof ) ) {
+	const char	*kernel;
+
 	/* Now use TFTP to load file */
 #ifdef	DOWNLOAD_PROTO_NFS
 	rpc_init();
 #endif
 		: KERNEL_BUF;
 	if ( kernel ) {
-		loadkernel(kernel); /* We don't return except on error */
+		loadkernel(kernel,process); /* We don't return except on error */
 		printf("Unable to load file.\n");
 	} else {	
 		printf("No filename\n");
 	.name			= "NIC",
 	.type_dev		= ( struct type_dev * ) &nic,
 	.describe_device	= nic_describe_device,
+	.configure		= nic_configure,
+	.load			= nic_load,
 };
 
 /* Careful.  We need an aligned buffer to avoid problems on machines

src/include/dev.h

 	char *name;
 	struct type_dev *type_dev; /* single instance */
 	char * ( * describe_device ) ( struct type_dev *type_dev );
+	int ( * configure ) ( struct type_dev *type_dev );
+	int ( * load ) ( struct type_dev *type_dev, 
+			 int ( * process ) ( unsigned char *data,
+					     unsigned int blocknum,
+					     unsigned int len, int eof ) );
 };
 
 #define __type_driver __attribute__ (( used, __section__ ( ".drivers.type" ) ))
 	dev->bus_driver = bus_driver;
 	memcpy ( &dev->bus_loc, bus_loc, sizeof ( dev->bus_loc ) );
 }
+/* Configure a device */
+static inline int configure ( struct dev *dev ) {
+	return dev->type_driver->configure ( dev->type_dev );
+}
+/* Boot from a device */
+static inline int load ( struct dev *dev,
+			 int ( * process ) ( unsigned char *data,
+					     unsigned int blocknum, 
+					     unsigned int len, int eof ) ) {
+	return dev->type_driver->load ( dev->type_dev, process );
+}
 
 /* Linker symbols for the various tables */
 extern struct bus_driver bus_drivers[];

src/include/etherboot.h

 /* main.c */
 struct Elf_Bhdr;
 extern int main();
-extern int loadkernel P((const char *fname));
+extern int loadkernel P((const char *fname, int (*)(unsigned char *, unsigned int, unsigned int, int)));
 extern char as_main_program;
 /* nic.c */
 extern void rx_qdrain P((void));