Updated to new API.

src/drivers/net/skel.c

 	 */
 }
 
-/**************************************************************************
- * DISABLE - Turn off ethernet interface
- **************************************************************************
- */
-static void skel_disable ( struct nic *nic __unused ) {
-	/* put the card in its initial state */
-	/* This function serves 3 purposes.
-	 * This disables DMA and interrupts so we don't receive
-	 *  unexpected packets or interrupts from the card after
-	 *  etherboot has finished. 
-	 * This frees resources so etherboot may use
-	 *  this driver on another interface
-	 * This allows etherboot to reinitialize the interface
-	 *  if something is something goes wrong.
-	 */
-}
-
 /**************************************************************************
  * IRQ - handle interrupts
  **************************************************************************
 	.poll		= skel_poll,
 	.transmit	= skel_transmit,
 	.irq		= skel_irq,
-
 };
 
 /**************************************************************************
  * PROBE - Look for an adapter
  *
- * You need to define a probe routine for each bus type that your
- * driver supports, together with tables that enable Etherboot to
- * identify that your driver should be used for a particular device.
+ * You need to define a probe routine and a disable routine for each
+ * bus type that your driver supports, together with tables that
+ * enable Etherboot to identify that your driver should be used for a
+ * particular device.
  *
  * Delete whichever of the following sections you don't need.  For
  * example, most PCI devices will only need the PCI probing section;
  */
 
 /**************************************************************************
- * PCI PROBE - Look for an adapter
+ * PCI PROBE and DISABLE
  **************************************************************************
  */
 static int skel_pci_probe ( struct nic *nic, struct pci_device *pci ) {
 
-
 	pci_fill_nic ( nic, pci );
 
-
-	nic->ioaddr = pci->ioaddr;
-	nic->irqno = pci->irq;
-
 	/* Test for physical presence of NIC */
 	/*
 	   if ( ! my_tests ) {
 	return 1;
 }
 
+static void skel_pci_disable ( struct nic *nic __unused,
+			       struct pci_device *pci __unused ) {
+	/* Reset the card to its initial state, disable DMA and
+	 * interrupts
+	 */
+}
+
 static struct pci_id skel_pci_nics[] = {
 PCI_ROM ( 0x0000, 0x0000, "skel-pci", "Skeleton PCI Adapter" ),
 };
 	PCI_DRIVER ( skel_pci_nics, PCI_NO_CLASS );
 
 DRIVER ( "SKEL/PCI", nic_driver, pci_driver, skel_pci_driver,
-	 skel_pci_probe, skel_disable );
+	 skel_pci_probe, skel_pci_disable );
 
 /**************************************************************************
- * EISA PROBE - Look for an adapter
+ * EISA PROBE and DISABLE
  **************************************************************************
  */
 static int skel_eisa_probe ( struct nic *nic, struct eisa_device *eisa ) {
-	struct nic *nic = nic_device ( dev );
 
+	eisa_fill_nic ( nic, eisa );
 	enable_eisa_device ( eisa );
-	nic->ioaddr = eisa->ioaddr;
-	nic->irqno = 0;
+	nic->irqno = 0; /* No standard way to get irq from EISA cards */
 
 	/* Test for physical presence of NIC */
 	/*
 	return 1;
 }
 
+static void skel_eisa_disable ( struct nic *nic __unused,
+				struct eisa_device *eisa ) {
+	/* Reset the card to its initial state, disable DMA and
+	 * interrupts
+	 */
+	disable_eisa_device ( eisa );
+}
+
 static struct eisa_id skel_eisa_nics[] = {
 	{ "Skeleton EISA Adapter", EISA_VENDOR('S','K','L'), 0x0000 },
 };
 
 static struct eisa_driver skel_eisa_driver =
-	EISA_DRIVER ( "SKEL/EISA", skel_eisa_nics );
+	EISA_DRIVER ( skel_eisa_nics );
 
-BOOT_DRIVER ( "SKEL/EISA", find_eisa_boot_device,
-	      skel_eisa_driver, skel_eisa_probe );
+DRIVER ( "SKEL/EISA", nic_driver, eisa_driver, skel_eisa_driver,
+	 skel_eisa_probe, skel_eisa_disable );
 
 ISA_ROM ( "skel-eisa", "Skeleton EISA Adapter" );
 
 /**************************************************************************
- * ISAPnP PROBE - Look for an adapter
+ * ISAPnP PROBE and DISABLE
  **************************************************************************
  */
 static int skel_isapnp_probe ( struct nic *nic,
 			       struct isapnp_device *isapnp ) {
-	struct nic *nic = nic_device ( dev );
 
-	nic->ioaddr = isapnp->ioaddr;
-	nic->irqno = isapnp->irqno;
-	activate_isapnp_device ( isapnp, 1 );
+	isapnp_fill_nic ( nic, isapnp );
+	activate_isapnp_device ( isapnp );
 
 	/* Test for physical presence of NIC */
 	/*
 	return 1;
 }
 
+static void skel_isapnp_disable ( struct nic *nic __unused,
+				  struct isapnp_device *isapnp ) {
+	/* Reset the card to its initial state, disable DMA and
+	 * interrupts
+	 */
+	deactivate_isapnp_device ( isapnp );
+}
+
 static struct isapnp_id skel_isapnp_nics[] = {
 	{ "Skeleton ISAPnP Adapter", ISAPNP_VENDOR('S','K','L'), 0x0000 },
 };
 
 static struct isapnp_driver skel_isapnp_driver =
-	ISAPNP_DRIVER ( "SKEL/ISAPnP", skel_isapnp_nics );
+	ISAPNP_DRIVER ( skel_isapnp_nics );
 
-BOOT_DRIVER ( "SKEL/ISAPnP", find_isapnp_boot_device,
-	      skel_isapnp_driver, skel_isapnp_probe );
+DRIVER ( "SKEL/ISAPnP", nic_driver, isapnp_driver, skel_isapnp_driver,
+	 skel_isapnp_probe, skel_isapnp_disable );
 
 ISA_ROM ( "skel-isapnp", "Skeleton ISAPnP Adapter" );
 
 /**************************************************************************
- * MCA PROBE - Look for an adapter
+ * MCA PROBE and DISABLE
  **************************************************************************
  */
 static int skel_mca_probe ( struct nic *nic,
-			    struct mca_device *mca __unused ) {
-	struct nic *nic = nic_device ( dev );
+			    struct mca_device *mca ) {
+
+	mca_fill_nic ( nic, mca );
 
 	/* MCA parameters are available in the mca->pos[] array */
 	/*
 	return 1;
 }
 
+static void skel_mca_disable ( struct nic *nic __unused,
+			       struct mca_device *mca __unused ) {
+	/* Reset the card to its initial state, disable DMA and
+	 * interrupts
+	 */
+}
+
 static struct mca_id skel_mca_nics[] = {
 	{ "Skeleton MCA Adapter", 0x0000 },
 };
 
 static struct mca_driver skel_mca_driver =
-	MCA_DRIVER ( "SKEL/MCA", skel_mca_nics );
+	MCA_DRIVER ( skel_mca_nics );
 
-BOOT_DRIVER ( "SKEL/MCA", find_mca_boot_device,
-	      skel_mca_driver, skel_mca_probe );
+DRIVER ( "SKEL/MCA", nic_driver, mca_driver, skel_mca_driver,
+	 skel_mca_probe, skel_mca_disable );
 
 ISA_ROM ( "skel-mca", "Skeleton MCA Adapter" );
 
 /**************************************************************************
- * ISA PROBE - Look for an adapter
+ * ISA PROBE and DISABLE
  *
  * The "classical" ISA probe is split into two stages: trying a list
  * of I/O addresses to see if there's anything listening, and then
 }
 
 static int skel_isa_probe ( struct nic *nic, struct isa_device *isa ) {
-	struct nic *nic = nic_device ( dev );
 
-	nic->ioaddr = isa->ioaddr;
-	nic->irqno = 0;
+	isa_fill_nic ( nic, isa );
+	nic->irqno = 0; /* No standard way to get IRQ for ISA */
 
 	/* Test for physical presence of NIC */
 	/*
 	return 1;
 }
 
+static void skel_isa_disable ( struct nic *nic __unused,
+			      struct isa_device *isa __unused ) {
+	/* Reset the card to its initial state, disable DMA and
+	 * interrupts
+	 */
+}
+
 static isa_probe_addr_t skel_isa_probe_addrs[] = {
 	/*
 	   0x200, 0x240,
 };
 
 static struct isa_driver skel_isa_driver =
-	ISA_DRIVER ( "SKEL/ISA", skel_isa_probe_addrs, skel_isa_probe_addr,
+	ISA_DRIVER ( skel_isa_probe_addrs, skel_isa_probe_addr,
 		     ISA_VENDOR('S','K','L'), 0x0000 );
 
-BOOT_DRIVER ( "SKEL/ISA", find_isa_boot_device,
-	      skel_isa_driver, skel_isa_probe );
+DRIVER ( "SKEL/ISA", nic_driver, isa_driver, skel_isa_driver,
+	 skel_isa_probe, skel_isa_disable );
 
 ISA_ROM ( "skel-isa", "Skeleton ISA Adapter" );