An attemp to make driver more readable and attaractive for further

hacking:
  - Remove all spaces at eol.
  - Improve style(9) in most frequently edited functions.
  - In em_encap() push variables for 82544 workaround in the block
    where they are only used.
  - In em_get_buf() remove unused variable.

1 files changed, 419 insertions, 459 deletions

diff --git a/sys/dev/em/if_em.c b/sys/dev/em/if_em.c
index 33fdb44..943dd2b 100644
--- a/sys/dev/em/if_em.c
+++ b/sys/dev/em/if_em.c
@@ -40,7 +40,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <dev/em/if_em.h>
 
 /*********************************************************************
- *  Set this to one to display debug statistics                                                   
+ *  Set this to one to display debug statistics
  *********************************************************************/
 int             em_display_debug_stats = 0;
 
@@ -132,7 +132,7 @@ static char *em_strings[] = {
 };
 
 /*********************************************************************
- *  Function prototypes            
+ *  Function prototypes
  *********************************************************************/
 static int  em_probe(device_t);
 static int  em_attach(device_t);
@@ -177,7 +177,7 @@ static int em_process_receive_interrupts(struct adapter *, int);
 #ifndef __NO_STRICT_ALIGNMENT
 static int  em_fixup_rx(struct adapter *);
 #endif
-static void em_receive_checksum(struct adapter *, 
+static void em_receive_checksum(struct adapter *,
 				struct em_rx_desc *,
 				struct mbuf *);
 static void em_transmit_checksum_setup(struct adapter *,
@@ -207,8 +207,8 @@ static void em_print_debug_info(struct adapter *);
 static int  em_is_valid_ether_addr(u_int8_t *);
 static int  em_sysctl_stats(SYSCTL_HANDLER_ARGS);
 static int  em_sysctl_debug_info(SYSCTL_HANDLER_ARGS);
-static u_int32_t em_fill_descriptors (bus_addr_t address, 
-				      u_int32_t length, 
+static u_int32_t em_fill_descriptors (bus_addr_t address,
+				      u_int32_t length,
 				      PDESC_ARRAY desc_array);
 static int  em_sysctl_int_delay(SYSCTL_HANDLER_ARGS);
 static void em_add_int_delay_sysctl(struct adapter *, const char *,
@@ -225,7 +225,7 @@ static poll_handler_t em_poll;
 #endif
 
 /*********************************************************************
- *  FreeBSD Device Interface Entry Points                    
+ *  FreeBSD Device Interface Entry Points
  *********************************************************************/
 
 static device_method_t em_methods[] = {
@@ -313,8 +313,8 @@ em_probe(device_t dev)
 
 		    ((pci_subdevice_id == ent->subdevice_id) ||
 		     (ent->subdevice_id == PCI_ANY_ID))) {
-			sprintf(adapter_name, "%s %s", 
-				em_strings[ent->index], 
+			sprintf(adapter_name, "%s %s",
+				em_strings[ent->index],
 				em_driver_version);
 			device_set_desc_copy(dev, adapter_name);
 			return(BUS_PROBE_DEFAULT);
@@ -329,9 +329,9 @@ em_probe(device_t dev)
  *  Device initialization routine
  *
  *  The attach entry point is called when the driver is being loaded.
- *  This routine identifies the type of hardware, allocates all resources 
- *  and initializes the hardware.     
- *  
+ *  This routine identifies the type of hardware, allocates all resources
+ *  and initializes the hardware.
+ *
  *  return 0 on success, positive on failure
  *********************************************************************/
 
@@ -361,7 +361,7 @@ em_attach(device_t dev)
                         OID_AUTO, "debug_info", CTLTYPE_INT|CTLFLAG_RW,
                         (void *)adapter, 0,
                         em_sysctl_debug_info, "I", "Debug Information");
-        
+
         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
                         SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
                         OID_AUTO, "stats", CTLTYPE_INT|CTLFLAG_RW,
@@ -430,7 +430,7 @@ em_attach(device_t dev)
         adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
         adapter->hw.tbi_compatibility_en = TRUE;
         adapter->rx_buffer_len = EM_RXBUFFER_2048;
-                        
+
 	adapter->hw.phy_init_script = 1;
 	adapter->hw.phy_reset_disable = FALSE;
 
@@ -439,29 +439,29 @@ em_attach(device_t dev)
 #else
 	adapter->hw.master_slave = EM_MASTER_SLAVE;
 #endif
-	/* 
-	 * Set the max frame size assuming standard ethernet 
-	 * sized frames 
-	 */   
-	adapter->hw.max_frame_size = 
+	/*
+	 * Set the max frame size assuming standard ethernet
+	 * sized frames.
+	 */
+	adapter->hw.max_frame_size =
 		ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN;
 
-	adapter->hw.min_frame_size = 
+	adapter->hw.min_frame_size =
 		MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN;
 
-	/* 
-	 * This controls when hardware reports transmit completion 
-	 * status. 
+	/*
+	 * This controls when hardware reports transmit completion
+	 * status.
 	 */
 	adapter->hw.report_tx_early = 1;
 
 	if (em_allocate_pci_resources(adapter)) {
-		printf("em%d: Allocation of PCI resources failed\n", 
+		printf("em%d: Allocation of PCI resources failed\n",
 		       adapter->unit);
                 error = ENXIO;
                 goto err_pci;
 	}
-  
+
 	
 	/* Initialize eeprom parameters */
         em_init_eeprom_params(&adapter->hw);
@@ -481,7 +481,7 @@ em_attach(device_t dev)
 	rsize = roundup2(adapter->num_rx_desc * sizeof(struct em_rx_desc),
 	    E1000_DBA_ALIGN);
 
-	/* Allocate Receive Descriptor ring */  
+	/* Allocate Receive Descriptor ring */
         if (em_dma_malloc(adapter, rsize, &adapter->rxdma, BUS_DMA_NOWAIT)) {
                 printf("em%d: Unable to allocate rx_desc memory\n",
                         adapter->unit);
@@ -570,7 +570,7 @@ err_pci:
  *  The detach entry point is called when the driver is being removed.
  *  This routine stops the adapter and deallocates all the resources
  *  that were allocated for driver operation.
- *  
+ *
  *  return 0 on success, positive on failure
  *********************************************************************/
 
@@ -620,7 +620,7 @@ em_detach(device_t dev)
  *
  *  Shutdown entry point
  *
- **********************************************************************/ 
+ **********************************************************************/
 
 static int
 em_shutdown(device_t dev)
@@ -677,40 +677,37 @@ em_resume(device_t dev)
 static void
 em_start_locked(struct ifnet *ifp)
 {
-        struct mbuf    *m_head;
-        struct adapter *adapter = ifp->if_softc;
+	struct adapter	*adapter = ifp->if_softc;
+	struct mbuf	*m_head;
 
 	mtx_assert(&adapter->mtx, MA_OWNED);
 
-        if (!adapter->link_active)
-                return;
-
-        while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
+	if (!adapter->link_active)
+		return;
 
-                IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
-                
-                if (m_head == NULL) break;
+	while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
 
+		IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
+		if (m_head == NULL)
+			break;
 		/*
 		 * em_encap() can modify our pointer, and or make it NULL on
 		 * failure.  In that event, we can't requeue.
 		 */
-		if (em_encap(adapter, &m_head)) { 
+		if (em_encap(adapter, &m_head)) {
 			if (m_head == NULL)
 				break;
 			ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 			IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
 			break;
-                }
+		}
 
 		/* Send a copy of the frame to the BPF listener */
 		BPF_MTAP(ifp, m_head);
-        
-                /* Set timeout in case hardware has problems transmitting */
-                ifp->if_timer = EM_TX_TIMEOUT;
-        
-        }
-        return;
+
+		/* Set timeout in case hardware has problems transmitting. */
+		ifp->if_timer = EM_TX_TIMEOUT;
+	}
 }
 
 static void
@@ -722,7 +719,6 @@ em_start(struct ifnet *ifp)
 	if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 		em_start_locked(ifp);
 	EM_UNLOCK(adapter);
-	return;
 }
 
 /*********************************************************************
@@ -737,11 +733,12 @@ em_start(struct ifnet *ifp)
 static int
 em_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 {
-	struct ifreq   *ifr = (struct ifreq *) data;
-	struct adapter * adapter = ifp->if_softc;
+	struct adapter	*adapter = ifp->if_softc;
+	struct ifreq	*ifr = (struct ifreq *)data;
 	int error = 0;
 
-	if (adapter->in_detach) return(error);
+	if (adapter->in_detach)
+		return(error);
 
 	switch (command) {
 	case SIOCSIFADDR:
@@ -775,7 +772,7 @@ em_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 
 		EM_LOCK(adapter);
 		ifp->if_mtu = ifr->ifr_mtu;
-		adapter->hw.max_frame_size = 
+		adapter->hw.max_frame_size =
 		ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
 		em_init_locked(adapter);
 		EM_UNLOCK(adapter);
@@ -877,8 +874,7 @@ em_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 static void
 em_watchdog(struct ifnet *ifp)
 {
-	struct adapter * adapter;
-	adapter = ifp->if_softc;
+	struct adapter *adapter = ifp->if_softc;
 
 	EM_LOCK(adapter);
 	/* If we are in this routine because of pause frames, then
@@ -905,7 +901,7 @@ em_watchdog(struct ifnet *ifp)
  *
  *  This routine is used in two ways. It is used by the stack as
  *  init entry point in network interface structure. It is also used
- *  by the driver as a hw/sw initialization routine to get to a 
+ *  by the driver as a hw/sw initialization routine to get to a
  *  consistent state.
  *
  *  return 0 on success, positive on failure
@@ -966,7 +962,7 @@ em_init_locked(struct adapter * adapter)
 
 	/* Initialize the hardware */
 	if (em_hardware_init(adapter)) {
-		printf("em%d: Unable to initialize the hardware\n", 
+		printf("em%d: Unable to initialize the hardware\n",
 		       adapter->unit);
 		return;
 	}
@@ -976,9 +972,9 @@ em_init_locked(struct adapter * adapter)
 
 	/* Prepare transmit descriptors and buffers */
 	if (em_setup_transmit_structures(adapter)) {
-		printf("em%d: Could not setup transmit structures\n", 
+		printf("em%d: Could not setup transmit structures\n",
 		       adapter->unit);
-		em_stop(adapter); 
+		em_stop(adapter);
 		return;
 	}
 	em_initialize_transmit_unit(adapter);
@@ -988,13 +984,13 @@ em_init_locked(struct adapter * adapter)
 
 	/* Prepare receive descriptors and buffers */
 	if (em_setup_receive_structures(adapter)) {
-		printf("em%d: Could not setup receive structures\n", 
+		printf("em%d: Could not setup receive structures\n",
 		       adapter->unit);
 		em_stop(adapter);
 		return;
 	}
 	em_initialize_receive_unit(adapter);
- 
+
 	/* Don't loose promiscuous settings */
 	em_set_promisc(adapter);
 
@@ -1040,35 +1036,36 @@ em_init(void *arg)
 
 
 #ifdef DEVICE_POLLING
-static void     
+static void
 em_poll_locked(struct ifnet *ifp, enum poll_cmd cmd, int count)
 {
-        struct adapter *adapter = ifp->if_softc;
-        u_int32_t reg_icr;
+	struct adapter *adapter = ifp->if_softc;
+	uint32_t reg_icr;
 
 	mtx_assert(&adapter->mtx, MA_OWNED);
 
-        if (cmd == POLL_AND_CHECK_STATUS) {
-                reg_icr = E1000_READ_REG(&adapter->hw, ICR);
-                if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
+	if (cmd == POLL_AND_CHECK_STATUS) {
+		reg_icr = E1000_READ_REG(&adapter->hw, ICR);
+		if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
 			callout_stop(&adapter->timer);
-                        adapter->hw.get_link_status = 1;
-                        em_check_for_link(&adapter->hw);
-                        em_print_link_status(adapter);
-			callout_reset(&adapter->timer, hz, em_local_timer, adapter);
-                }
+			adapter->hw.get_link_status = 1;
+			em_check_for_link(&adapter->hw);
+			em_print_link_status(adapter);
+			callout_reset(&adapter->timer, hz, em_local_timer,
+			    adapter);
+		}
         }
 	em_process_receive_interrupts(adapter, count);
 	em_clean_transmit_interrupts(adapter);
-	
-        if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
-                em_start_locked(ifp);
+
+	if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
+		em_start_locked(ifp);
 }
-        
-static void     
+
+static void
 em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
 {
-        struct adapter *adapter = ifp->if_softc;
+	struct adapter *adapter = ifp->if_softc;
 
 	EM_LOCK(adapter);
 	if (ifp->if_drv_flags & IFF_DRV_RUNNING)
@@ -1128,7 +1125,7 @@ em_handle_rxtx(void *context, int pending)
 
 /*********************************************************************
  *
- *  Interrupt Service routine  
+ *  Interrupt Service routine
  *
  **********************************************************************/
 #ifndef NO_EM_FASTINTR
@@ -1139,7 +1136,7 @@ em_intr_fast(void *arg)
 	struct ifnet	*ifp;
 	uint32_t	reg_icr;
 
-	ifp = adapter->ifp;  
+	ifp = adapter->ifp;
 
 #ifdef DEVICE_POLLING
 	if (ifp->if_capenable & IFCAP_POLLING) {
@@ -1194,14 +1191,14 @@ em_intr(void *arg)
 
 	EM_LOCK(adapter);
 
-	ifp = adapter->ifp;  
+	ifp = adapter->ifp;
 
 #ifdef DEVICE_POLLING
 	if (ifp->if_capenable & IFCAP_POLLING) {
 		EM_UNLOCK(adapter);
 		return;
 	}
-#endif /* DEVICE_POLLING */
+#endif
 
 	for (;;) {
 		reg_icr = E1000_READ_REG(&adapter->hw, ICR);
@@ -1224,7 +1221,7 @@ em_intr(void *arg)
 			em_process_receive_interrupts(adapter, -1);
 			em_clean_transmit_interrupts(adapter);
 		}
-                 
+
 		/* Link status change */
 		if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
 			callout_stop(&adapter->timer);
@@ -1249,11 +1246,8 @@ em_intr(void *arg)
 		em_start_locked(ifp);
 
 	EM_UNLOCK(adapter);
-	return;
 }
 
-
-
 /*********************************************************************
  *
  *  Media Ioctl callback
@@ -1272,8 +1266,8 @@ em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
 	em_check_for_link(&adapter->hw);
 	if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
 		if (adapter->link_active == 0) {
-			em_get_speed_and_duplex(&adapter->hw, 
-						&adapter->link_speed, 
+			em_get_speed_and_duplex(&adapter->hw,
+						&adapter->link_speed,
 						&adapter->link_duplex);
 			adapter->link_active = 1;
 		}
@@ -1380,70 +1374,63 @@ em_media_change(struct ifnet *ifp)
  *
  *  return 0 on success, positive on failure
  **********************************************************************/
-static int              
+static int
 em_encap(struct adapter *adapter, struct mbuf **m_headp)
 {
-        u_int32_t       txd_upper;
-        u_int32_t       txd_lower, txd_used = 0, txd_saved = 0;
-        int             i, j, error = 0;
-	bus_dmamap_t	map;
-
-	struct mbuf	*m_head;
-
-	/* For 82544 Workaround */
-	DESC_ARRAY              desc_array;
-	u_int32_t               array_elements;
-	u_int32_t               counter;
-        struct m_tag    *mtag;
+        struct ifnet		*ifp = adapter->ifp;
 	bus_dma_segment_t	segs[EM_MAX_SCATTER];
-	int			nsegs;
-        struct em_buffer   *tx_buffer;
-        struct em_tx_desc *current_tx_desc = NULL;
-        struct ifnet   *ifp = adapter->ifp;
+	bus_dmamap_t		map;
+        struct em_buffer	*tx_buffer;
+        struct em_tx_desc	*current_tx_desc;
+	struct mbuf		*m_head;
+        struct m_tag		*mtag;
+	uint32_t		txd_upper, txd_lower, txd_used, txd_saved;
+	int			nsegs, i, j;
+	int			error = 0;
 
 	m_head = *m_headp;
+	current_tx_desc = NULL;
+	txd_used = txd_saved = 0;
 
-        /*
-         * Force a cleanup if number of TX descriptors
-         * available hits the threshold
-         */
-        if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
-                em_clean_transmit_interrupts(adapter);
-                if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
-                        adapter->no_tx_desc_avail1++;
-                        return(ENOBUFS);
-                }
-        }
+	/*
+	 * Force a cleanup if number of TX descriptors
+	 * available hits the threshold.
+	 */
+	if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
+		em_clean_transmit_interrupts(adapter);
+		if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
+			adapter->no_tx_desc_avail1++;
+			return(ENOBUFS);
+		}
+	}
 
-        /*
-         * Map the packet for DMA.
-         */
+	/*
+	 * Map the packet for DMA.
+	 */
 	tx_buffer = &adapter->tx_buffer_area[adapter->next_avail_tx_desc];
 	error = bus_dmamap_load_mbuf_sg(adapter->txtag, tx_buffer->map, m_head,
 	    segs, &nsegs, BUS_DMA_NOWAIT);
 	map = tx_buffer->map;
-        if (error != 0) {
-                adapter->no_tx_dma_setup++;
-                return (error);
-        }
-        KASSERT(nsegs != 0, ("em_encap: empty packet"));
+	if (error != 0) {
+		adapter->no_tx_dma_setup++;
+		return (error);
+	}
+	KASSERT(nsegs != 0, ("em_encap: empty packet"));
 
-        if (nsegs > adapter->num_tx_desc_avail) {
-                adapter->no_tx_desc_avail2++;
+	if (nsegs > adapter->num_tx_desc_avail) {
+		adapter->no_tx_desc_avail2++;
 		error = ENOBUFS;
 		goto encap_fail;
-        }
-
-
-        if (ifp->if_hwassist > 0) {
-                em_transmit_checksum_setup(adapter,  m_head,
-                                           &txd_upper, &txd_lower);
-        } else
-                txd_upper = txd_lower = 0;
+	}
 
+	if (ifp->if_hwassist > 0) {
+		em_transmit_checksum_setup(adapter,  m_head, &txd_upper,
+		    &txd_lower);
+	} else
+		txd_upper = txd_lower = 0;
 
-        /* Find out if we are in vlan mode */
-        mtag = VLAN_OUTPUT_TAG(ifp, m_head);
+	/* Find out if we are in vlan mode. */
+	mtag = VLAN_OUTPUT_TAG(ifp, m_head);
 
 	/*
 	 * When operating in promiscuous mode, hardware encapsulation for
@@ -1484,19 +1471,22 @@ em_encap(struct adapter *adapter, struct mbuf **m_headp)
 		*m_headp = m_head;
 	}
 
-        i = adapter->next_avail_tx_desc;
+	i = adapter->next_avail_tx_desc;
 	if (adapter->pcix_82544) {
 		txd_saved = i;
 		txd_used = 0;
 	}
-        for (j = 0; j < nsegs; j++) {
-		/* If adapter is 82544 and on PCIX bus */
+	for (j = 0; j < nsegs; j++) {
+		/* If adapter is 82544 and on PCIX bus. */
 		if(adapter->pcix_82544) {
-			/* 
-			 * Check the Address and Length combination and 
-			 * split the data accordingly 
+			DESC_ARRAY	desc_array;
+			uint32_t	array_elements, counter;
+
+			/*
+			 * Check the Address and Length combination and
+			 * split the data accordingly
 			 */
-                        array_elements = em_fill_descriptors(segs[j].ds_addr,
+			array_elements = em_fill_descriptors(segs[j].ds_addr,
 			    segs[j].ds_len, &desc_array);
 			for (counter = 0; counter < array_elements; counter++) {
 				if (txd_used == adapter->num_tx_desc_avail) {
@@ -1504,21 +1494,21 @@ em_encap(struct adapter *adapter, struct mbuf **m_headp)
 					adapter->no_tx_desc_avail2++;
 					error = ENOBUFS;
 					goto encap_fail;
-                                }
-                                tx_buffer = &adapter->tx_buffer_area[i];
-                                current_tx_desc = &adapter->tx_desc_base[i];
-                                current_tx_desc->buffer_addr = htole64(
+				}
+				tx_buffer = &adapter->tx_buffer_area[i];
+				current_tx_desc = &adapter->tx_desc_base[i];
+				current_tx_desc->buffer_addr = htole64(
 					desc_array.descriptor[counter].address);
-                                current_tx_desc->lower.data = htole32(
-					(adapter->txd_cmd | txd_lower | 
-					 (u_int16_t)desc_array.descriptor[counter].length));
-                                current_tx_desc->upper.data = htole32((txd_upper));
-                                if (++i == adapter->num_tx_desc)
-                                         i = 0;
-
-                                tx_buffer->m_head = NULL;
-                                txd_used++;
-                        }
+				current_tx_desc->lower.data = htole32(
+					(adapter->txd_cmd | txd_lower |
+					(uint16_t)desc_array.descriptor[counter].length));
+				current_tx_desc->upper.data = htole32((txd_upper));
+				if (++i == adapter->num_tx_desc)
+					i = 0;
+
+				tx_buffer->m_head = NULL;
+				txd_used++;
+			}
 		} else {
 			tx_buffer = &adapter->tx_buffer_area[i];
 			current_tx_desc = &adapter->tx_desc_base[i];
@@ -1533,49 +1523,48 @@ em_encap(struct adapter *adapter, struct mbuf **m_headp)
 
 			tx_buffer->m_head = NULL;
 		}
-        }
+	}
 
 	adapter->next_avail_tx_desc = i;
-	if (adapter->pcix_82544) {
+	if (adapter->pcix_82544)
 		adapter->num_tx_desc_avail -= txd_used;
-	}
-	else {
+	else
 		adapter->num_tx_desc_avail -= nsegs;
-	}
 
-        if (mtag != NULL) {
-                /* Set the vlan id */
-                current_tx_desc->upper.fields.special = htole16(VLAN_TAG_VALUE(mtag));
+	if (mtag != NULL) {
+		/* Set the vlan id. */
+		current_tx_desc->upper.fields.special =
+		    htole16(VLAN_TAG_VALUE(mtag));
 
-                /* Tell hardware to add tag */
-                current_tx_desc->lower.data |= htole32(E1000_TXD_CMD_VLE);
-        }
+		/* Tell hardware to add tag. */
+		current_tx_desc->lower.data |= htole32(E1000_TXD_CMD_VLE);
+	}
 
-        tx_buffer->m_head = m_head;
-        bus_dmamap_sync(adapter->txtag, map, BUS_DMASYNC_PREWRITE);
+	tx_buffer->m_head = m_head;
+	bus_dmamap_sync(adapter->txtag, map, BUS_DMASYNC_PREWRITE);
 
-        /*
-         * Last Descriptor of Packet needs End Of Packet (EOP)
-         */
-        current_tx_desc->lower.data |= htole32(E1000_TXD_CMD_EOP);
+	/*
+	 * Last Descriptor of Packet needs End Of Packet (EOP).
+	 */
+	current_tx_desc->lower.data |= htole32(E1000_TXD_CMD_EOP);
 
-        /*
-         * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000
-         * that this frame is available to transmit.
-         */
-        bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
+	/*
+	 * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000
+	 * that this frame is available to transmit.
+	 */
+	bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
             BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
-        if (adapter->hw.mac_type == em_82547 &&
-            adapter->link_duplex == HALF_DUPLEX) {
-                em_82547_move_tail_locked(adapter);
-        } else {
-                E1000_WRITE_REG(&adapter->hw, TDT, i);
-                if (adapter->hw.mac_type == em_82547) {
-                        em_82547_update_fifo_head(adapter, m_head->m_pkthdr.len);
-                }
-        }
+	if (adapter->hw.mac_type == em_82547 &&
+	    adapter->link_duplex == HALF_DUPLEX) {
+		em_82547_move_tail_locked(adapter);
+	} else {
+		E1000_WRITE_REG(&adapter->hw, TDT, i);
+		if (adapter->hw.mac_type == em_82547) {
+			em_82547_update_fifo_head(adapter, m_head->m_pkthdr.len);
+		}
+	}
 
-        return(0);
+	return(0);
 
 encap_fail:
 	bus_dmamap_unload(adapter->txtag, tx_buffer->map);
@@ -1585,7 +1574,7 @@ encap_fail:
 /*********************************************************************
  *
  * 82547 workaround to avoid controller hang in half-duplex environment.
- * The workaround is to avoid queuing a large packet that would span   
+ * The workaround is to avoid queuing a large packet that would span
  * the internal Tx FIFO ring boundary. We need to reset the FIFO pointers
  * in this case. We do that only when FIFO is quiescent.
  *
@@ -1629,11 +1618,11 @@ em_82547_move_tail_locked(struct adapter *adapter)
 static void
 em_82547_move_tail(void *arg)
 {
-        struct adapter *adapter = arg;
+	struct adapter *adapter = arg;
 
-        EM_LOCK(adapter);
-        em_82547_move_tail_locked(adapter);
-        EM_UNLOCK(adapter);
+	EM_LOCK(adapter);
+	em_82547_move_tail_locked(adapter);
+	EM_UNLOCK(adapter);
 }
 
 static int
@@ -1647,12 +1636,10 @@ em_82547_fifo_workaround(struct adapter *adapter, int len)
 		fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
 
 		if (fifo_pkt_len >= (EM_82547_PKT_THRESH + fifo_space)) {
-			if (em_82547_tx_fifo_reset(adapter)) {
+			if (em_82547_tx_fifo_reset(adapter))
 				return(0);
-			}
-			else {
+			else
 				return(1);
-			}
 		}
 	}
 
@@ -1681,7 +1668,7 @@ em_82547_tx_fifo_reset(struct adapter *adapter)
 
 	if ( (E1000_READ_REG(&adapter->hw, TDT) ==
 	      E1000_READ_REG(&adapter->hw, TDH)) &&
-	     (E1000_READ_REG(&adapter->hw, TDFT) == 
+	     (E1000_READ_REG(&adapter->hw, TDFT) ==
 	      E1000_READ_REG(&adapter->hw, TDFH)) &&
 	     (E1000_READ_REG(&adapter->hw, TDFTS) ==
 	      E1000_READ_REG(&adapter->hw, TDFHS)) &&
@@ -1714,17 +1701,16 @@ em_82547_tx_fifo_reset(struct adapter *adapter)
 static void
 em_set_promisc(struct adapter * adapter)
 {
-
-	u_int32_t       reg_rctl;
-	struct ifnet   *ifp = adapter->ifp;
+	struct ifnet	*ifp = adapter->ifp;
+	uint32_t	reg_rctl;
 
 	reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
 
 	if (ifp->if_flags & IFF_PROMISC) {
 		reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
 		E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
-		/* Disable VLAN stripping in promiscous mode 
-		 * This enables bridging of vlan tagged frames to occur 
+		/* Disable VLAN stripping in promiscous mode
+		 * This enables bridging of vlan tagged frames to occur
 		 * and also allows vlan tags to be seen in tcpdump
 		 */
 		if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
@@ -1737,15 +1723,13 @@ em_set_promisc(struct adapter * adapter)
 		adapter->em_insert_vlan_header = 0;
 	} else
 		adapter->em_insert_vlan_header = 0;
-
-	return;
 }
 
 static void
 em_disable_promisc(struct adapter * adapter)
 {
-	u_int32_t       reg_rctl;
-	struct ifnet   *ifp = adapter->ifp;
+	struct ifnet	*ifp = adapter->ifp;
+	uint32_t	reg_rctl;
 
 	reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
 
@@ -1756,8 +1740,6 @@ em_disable_promisc(struct adapter * adapter)
 	if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
 		em_enable_vlans(adapter);
 	adapter->em_insert_vlan_header = 0;
-
-	return;
 }
 
 
@@ -1771,55 +1753,52 @@ em_disable_promisc(struct adapter * adapter)
 static void
 em_set_multi(struct adapter * adapter)
 {
-        u_int32_t reg_rctl = 0;
-        u_int8_t  mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS];
-        struct ifmultiaddr  *ifma;
+        struct ifnet	*ifp = adapter->ifp;
+        struct ifmultiaddr *ifma;
+        uint32_t reg_rctl = 0;
+        uint8_t  mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS];
         int mcnt = 0;
-        struct ifnet   *ifp = adapter->ifp;
-    
-        IOCTL_DEBUGOUT("em_set_multi: begin");
- 
-        if (adapter->hw.mac_type == em_82542_rev2_0) {
-                reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
-                if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 
+
+	IOCTL_DEBUGOUT("em_set_multi: begin");
+
+	if (adapter->hw.mac_type == em_82542_rev2_0) {
+		reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
+		if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE)
                         em_pci_clear_mwi(&adapter->hw);
-                }
-                reg_rctl |= E1000_RCTL_RST;
-                E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
-                msec_delay(5);
-        }
+		reg_rctl |= E1000_RCTL_RST;
+		E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
+		msec_delay(5);
+	}
 
 	IF_ADDR_LOCK(ifp);
         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
-                if (ifma->ifma_addr->sa_family != AF_LINK)
-                        continue;
- 
-		if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) break;
-
-                bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
-                      &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS);
-                mcnt++;
-        }
+		if (ifma->ifma_addr->sa_family != AF_LINK)
+			continue;
+
+		if (mcnt == MAX_NUM_MULTICAST_ADDRESSES)
+			break;
+
+		bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
+		    &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS);
+		mcnt++;
+	}
 	IF_ADDR_UNLOCK(ifp);
 
-        if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) {
-                reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
-                reg_rctl |= E1000_RCTL_MPE;
-                E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
-        } else
-                em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0, 1);
-
-        if (adapter->hw.mac_type == em_82542_rev2_0) {
-                reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
-                reg_rctl &= ~E1000_RCTL_RST;
-                E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
-                msec_delay(5);
-                if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
-                        em_pci_set_mwi(&adapter->hw);
-                }
-        }
+	if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) {
+		reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
+		reg_rctl |= E1000_RCTL_MPE;
+		E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
+	} else
+		em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0, 1);
 
-        return;
+	if (adapter->hw.mac_type == em_82542_rev2_0) {
+		reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
+		reg_rctl &= ~E1000_RCTL_RST;
+		E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
+		msec_delay(5);
+		if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE)
+			em_pci_set_mwi(&adapter->hw);
+	}
 }
 
 
@@ -1833,24 +1812,21 @@ em_set_multi(struct adapter * adapter)
 static void
 em_local_timer(void *arg)
 {
-	struct ifnet   *ifp;
-	struct adapter * adapter = arg;
-	ifp = adapter->ifp;
+	struct adapter	*adapter = arg;
+	struct ifnet	*ifp = adapter->ifp;
 
 	EM_LOCK(adapter);
 
 	em_check_for_link(&adapter->hw);
 	em_print_link_status(adapter);
-	em_update_stats_counters(adapter);   
-	if (em_display_debug_stats && ifp->if_drv_flags & IFF_DRV_RUNNING) {
+	em_update_stats_counters(adapter);
+	if (em_display_debug_stats && ifp->if_drv_flags & IFF_DRV_RUNNING)
 		em_print_hw_stats(adapter);
-	}
 	em_smartspeed(adapter);
 
 	callout_reset(&adapter->timer, hz, em_local_timer, adapter);
 
 	EM_UNLOCK(adapter);
-	return;
 }
 
 static void
@@ -1860,15 +1836,15 @@ em_print_link_status(struct adapter * adapter)
 
 	if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
 		if (adapter->link_active == 0) {
-			em_get_speed_and_duplex(&adapter->hw, 
-						&adapter->link_speed, 
-						&adapter->link_duplex);
+			em_get_speed_and_duplex(&adapter->hw,
+			    &adapter->link_speed,
+			    &adapter->link_duplex);
 			if (bootverbose)
 				printf("em%d: Link is up %d Mbps %s\n",
-				       adapter->unit,
-				       adapter->link_speed,
-				       ((adapter->link_duplex == FULL_DUPLEX) ?
-					"Full Duplex" : "Half Duplex"));
+				    adapter->unit,
+				    adapter->link_speed,
+				    ((adapter->link_duplex == FULL_DUPLEX) ?
+				    "Full Duplex" : "Half Duplex"));
 			adapter->link_active = 1;
 			adapter->smartspeed = 0;
 			if_link_state_change(ifp, LINK_STATE_UP);
@@ -1883,25 +1859,22 @@ em_print_link_status(struct adapter * adapter)
 			if_link_state_change(ifp, LINK_STATE_DOWN);
 		}
 	}
-
-	return;
 }
 
 /*********************************************************************
  *
  *  This routine disables all traffic on the adapter by issuing a
- *  global reset on the MAC and deallocates TX/RX buffers. 
+ *  global reset on the MAC and deallocates TX/RX buffers.
  *
  **********************************************************************/
 
 static void
 em_stop(void *arg)
 {
-	struct ifnet   *ifp;
-	struct adapter * adapter = arg;
-	ifp = adapter->ifp;
+	struct adapter	*adapter = arg;
+	struct ifnet	*ifp = adapter->ifp;
 
-	mtx_assert(&adapter->mtx, MA_OWNED);
+	EM_LOCK_ASSERT(adapter);
 
 	INIT_DEBUGOUT("em_stop: begin");
 
@@ -1912,11 +1885,8 @@ em_stop(void *arg)
 	em_free_transmit_structures(adapter);
 	em_free_receive_structures(adapter);
 
-
 	/* Tell the stack that the interface is no longer active */
 	ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
-
-	return;
 }
 
 
@@ -1934,9 +1904,9 @@ em_identify_hardware(struct adapter * adapter)
 	adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2);
 	if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) &&
 	      (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) {
-		printf("em%d: Memory Access and/or Bus Master bits were not set!\n", 
+		printf("em%d: Memory Access and/or Bus Master bits were not set!\n",
 		       adapter->unit);
-		adapter->hw.pci_cmd_word |= 
+		adapter->hw.pci_cmd_word |=
 		(PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN);
 		pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2);
 	}
@@ -1952,9 +1922,9 @@ em_identify_hardware(struct adapter * adapter)
         if (em_set_mac_type(&adapter->hw))
                 printf("em%d: Unknown MAC Type\n", adapter->unit);
 	
-	if(adapter->hw.mac_type == em_82541 || 
+	if(adapter->hw.mac_type == em_82541 ||
 	   adapter->hw.mac_type == em_82541_rev_2 ||
-	   adapter->hw.mac_type == em_82547 || 
+	   adapter->hw.mac_type == em_82547 ||
 	   adapter->hw.mac_type == em_82547_rev_2)
 		adapter->hw.phy_init_script = TRUE;
 
@@ -1971,13 +1941,13 @@ em_allocate_pci_resources(struct adapter * adapter)
 	adapter->res_memory = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
 						     &rid, RF_ACTIVE);
 	if (!(adapter->res_memory)) {
-		printf("em%d: Unable to allocate bus resource: memory\n", 
+		printf("em%d: Unable to allocate bus resource: memory\n",
 		       adapter->unit);
 		return(ENXIO);
 	}
-	adapter->osdep.mem_bus_space_tag = 
+	adapter->osdep.mem_bus_space_tag =
 	rman_get_bustag(adapter->res_memory);
-	adapter->osdep.mem_bus_space_handle = 
+	adapter->osdep.mem_bus_space_handle =
 	rman_get_bushandle(adapter->res_memory);
 	adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle;
 
@@ -1999,14 +1969,14 @@ em_allocate_pci_resources(struct adapter * adapter)
 			printf("em%d: Unable to locate IO BAR\n", adapter->unit);
 			return (ENXIO);
 		}
-		adapter->res_ioport = bus_alloc_resource_any(dev, 
+		adapter->res_ioport = bus_alloc_resource_any(dev,
 							     SYS_RES_IOPORT,
 							     &adapter->io_rid,
 							     RF_ACTIVE);
 		if (!(adapter->res_ioport)) {
 			printf("em%d: Unable to allocate bus resource: ioport\n",
 			       adapter->unit);
-			return(ENXIO);  
+			return(ENXIO);
 		}
 		adapter->hw.io_base = 0;
 		adapter->osdep.io_bus_space_tag =
@@ -2017,10 +1987,10 @@ em_allocate_pci_resources(struct adapter * adapter)
 
 	rid = 0x0;
 	adapter->res_interrupt = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
-						        RF_SHAREABLE | 
+						        RF_SHAREABLE |
 							RF_ACTIVE);
 	if (!(adapter->res_interrupt)) {
-		printf("em%d: Unable to allocate bus resource: interrupt\n", 
+		printf("em%d: Unable to allocate bus resource: interrupt\n",
 		       adapter->unit);
 		return(ENXIO);
 	}
@@ -2063,7 +2033,7 @@ em_allocate_intr(struct adapter *adapter)
 				   INTR_TYPE_NET | INTR_MPSAFE,
 				   em_intr, adapter,
 				   &adapter->int_handler_tag)) {
-			printf("em%d: Error registering interrupt handler!\n", 
+			printf("em%d: Error registering interrupt handler!\n",
 			       adapter->unit);
 			return(ENXIO);
 		}
@@ -2079,7 +2049,7 @@ em_free_intr(struct adapter *adapter)
 	device_t dev = adapter->dev;
 
 	if (adapter->res_interrupt != NULL) {
-		bus_teardown_intr(dev, adapter->res_interrupt, 
+		bus_teardown_intr(dev, adapter->res_interrupt,
 				  adapter->int_handler_tag);
 		adapter->int_handler_tag = NULL;
 	}
@@ -2097,16 +2067,16 @@ em_free_pci_resources(struct adapter * adapter)
 	device_t dev = adapter->dev;
 
 	if (adapter->res_interrupt != NULL) {
-		bus_release_resource(dev, SYS_RES_IRQ, 0, 
+		bus_release_resource(dev, SYS_RES_IRQ, 0,
 				     adapter->res_interrupt);
 	}
 	if (adapter->res_memory != NULL) {
-		bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(0), 
+		bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(0),
 				     adapter->res_memory);
 	}
 
 	if (adapter->res_ioport != NULL) {
-		bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid, 
+		bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid,
 				     adapter->res_ioport);
 	}
 	return;
@@ -2146,7 +2116,7 @@ em_hardware_init(struct adapter * adapter)
 	}
 
 	/*
-	 * These parameters control the automatic generation (Tx) and 
+	 * These parameters control the automatic generation (Tx) and
 	 * response (Rx) to Ethernet PAUSE frames.
 	 * - High water mark should allow for at least two frames to be
 	 *   received after sending an XOFF.
@@ -2180,8 +2150,8 @@ em_hardware_init(struct adapter * adapter)
 		adapter->link_active = 0;
 
 	if (adapter->link_active) {
-		em_get_speed_and_duplex(&adapter->hw, 
-					&adapter->link_speed, 
+		em_get_speed_and_duplex(&adapter->hw,
+					&adapter->link_speed,
 					&adapter->link_duplex);
 	} else {
 		adapter->link_speed = 0;
@@ -2238,26 +2208,26 @@ em_setup_interface(device_t dev, struct adapter * adapter)
 	ifp->if_capabilities |= IFCAP_POLLING;
 #endif
 
-	/* 
+	/*
 	 * Specify the media types supported by this adapter and register
 	 * callbacks to update media and link information
 	 */
 	ifmedia_init(&adapter->media, IFM_IMASK, em_media_change,
 		     em_media_status);
 	if (adapter->hw.media_type == em_media_type_fiber) {
-		ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 
+		ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX,
 			    0, NULL);
-		ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 
+		ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX,
 			    0, NULL);
 	} else {
 		ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL);
-		ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, 
+		ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX,
 			    0, NULL);
-		ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 
+		ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX,
 			    0, NULL);
-		ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 
+		ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX,
 			    0, NULL);
-		ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 
+		ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX,
 			    0, NULL);
 		ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL);
 	}
@@ -2272,13 +2242,13 @@ em_setup_interface(device_t dev, struct adapter * adapter)
  *
  *  Workaround for SmartSpeed on 82541 and 82547 controllers
  *
- **********************************************************************/        
+ **********************************************************************/
 static void
 em_smartspeed(struct adapter *adapter)
 {
         uint16_t phy_tmp;
- 
-	if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) || 
+
+	if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) ||
 	   !adapter->hw.autoneg || !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
 		return;
 
@@ -2300,7 +2270,7 @@ em_smartspeed(struct adapter *adapter)
                                    !em_phy_setup_autoneg(&adapter->hw) &&
 				   !em_read_phy_reg(&adapter->hw, PHY_CTRL,
                                                        &phy_tmp)) {
-                                        phy_tmp |= (MII_CR_AUTO_NEG_EN |  
+                                        phy_tmp |= (MII_CR_AUTO_NEG_EN |
                                                     MII_CR_RESTART_AUTO_NEG);
                                         em_write_phy_reg(&adapter->hw,
 							 PHY_CTRL, phy_tmp);
@@ -2334,7 +2304,7 @@ em_smartspeed(struct adapter *adapter)
  */
 static void
 em_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
-{ 
+{
         if (error)
                 return;
         *(bus_addr_t *) arg = segs[0].ds_addr;
@@ -2345,7 +2315,7 @@ em_dma_malloc(struct adapter *adapter, bus_size_t size,
         struct em_dma_alloc *dma, int mapflags)
 {
         int r;
-         
+
 	r = bus_dma_tag_create(NULL,                    /* parent */
                                E1000_DBA_ALIGN, 0,      /* alignment, bounds */
                                BUS_SPACE_MAXADDR,       /* lowaddr */
@@ -2417,8 +2387,8 @@ em_dma_free(struct adapter *adapter, struct em_dma_alloc *dma)
 
 /*********************************************************************
  *
- *  Allocate memory for tx_buffer structures. The tx_buffer stores all 
- *  the information needed to transmit a packet on the wire. 
+ *  Allocate memory for tx_buffer structures. The tx_buffer stores all
+ *  the information needed to transmit a packet on the wire.
  *
  **********************************************************************/
 static int
@@ -2428,7 +2398,7 @@ em_allocate_transmit_structures(struct adapter * adapter)
 	      (struct em_buffer *) malloc(sizeof(struct em_buffer) *
 					     adapter->num_tx_desc, M_DEVBUF,
 					     M_NOWAIT))) {
-		printf("em%d: Unable to allocate tx_buffer memory\n", 
+		printf("em%d: Unable to allocate tx_buffer memory\n",
 		       adapter->unit);
 		return ENOMEM;
 	}
@@ -2441,7 +2411,7 @@ em_allocate_transmit_structures(struct adapter * adapter)
 
 /*********************************************************************
  *
- *  Allocate and initialize transmit structures. 
+ *  Allocate and initialize transmit structures.
  *
  **********************************************************************/
 static int
@@ -2457,13 +2427,13 @@ em_setup_transmit_structures(struct adapter * adapter)
 	size = roundup2(adapter->hw.max_frame_size, MCLBYTES);
 	if ((error = bus_dma_tag_create(NULL,           /* parent */
                                1, 0,                    /* alignment, bounds */
-                               BUS_SPACE_MAXADDR,       /* lowaddr */ 
+                               BUS_SPACE_MAXADDR,       /* lowaddr */
                                BUS_SPACE_MAXADDR,       /* highaddr */
                                NULL, NULL,              /* filter, filterarg */
                                size,                    /* maxsize */
                                EM_MAX_SCATTER,          /* nsegments */
                                size,                    /* maxsegsize */
-                               0,                       /* flags */ 
+                               0,                       /* flags */
 			       NULL,			/* lockfunc */
 			       NULL,			/* lockarg */
                                &adapter->txtag)) != 0) {
@@ -2522,7 +2492,7 @@ em_initialize_transmit_unit(struct adapter * adapter)
 	bus_addr = adapter->txdma.dma_paddr;
 	E1000_WRITE_REG(&adapter->hw, TDBAL, (u_int32_t)bus_addr);
 	E1000_WRITE_REG(&adapter->hw, TDBAH, (u_int32_t)(bus_addr >> 32));
-	E1000_WRITE_REG(&adapter->hw, TDLEN, 
+	E1000_WRITE_REG(&adapter->hw, TDLEN,
 			adapter->num_tx_desc *
 			sizeof(struct em_tx_desc));
 
@@ -2531,7 +2501,7 @@ em_initialize_transmit_unit(struct adapter * adapter)
 	E1000_WRITE_REG(&adapter->hw, TDT, 0);
 
 
-	HW_DEBUGOUT2("Base = %x, Length = %x\n", 
+	HW_DEBUGOUT2("Base = %x, Length = %x\n",
 		     E1000_READ_REG(&adapter->hw, TDBAL),
 		     E1000_READ_REG(&adapter->hw, TDLEN));
 
@@ -2570,7 +2540,7 @@ em_initialize_transmit_unit(struct adapter * adapter)
 	}
 	E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl);
 
-	/* Setup Transmit Descriptor Settings for this adapter */   
+	/* Setup Transmit Descriptor Settings for this adapter */
 	adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS;
 
 	if (adapter->tx_int_delay.value > 0)
@@ -2634,7 +2604,7 @@ static void
 em_transmit_checksum_setup(struct adapter * adapter,
 			   struct mbuf *mp,
 			   u_int32_t *txd_upper,
-			   u_int32_t *txd_lower) 
+			   u_int32_t *txd_lower)
 {
 	struct em_context_desc *TXD;
 	struct em_buffer *tx_buffer;
@@ -2676,22 +2646,22 @@ em_transmit_checksum_setup(struct adapter * adapter,
 	TXD = (struct em_context_desc *) &adapter->tx_desc_base[curr_txd];
 
 	TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN;
-	TXD->lower_setup.ip_fields.ipcso = 
+	TXD->lower_setup.ip_fields.ipcso =
 		ETHER_HDR_LEN + offsetof(struct ip, ip_sum);
-	TXD->lower_setup.ip_fields.ipcse = 
+	TXD->lower_setup.ip_fields.ipcse =
 		htole16(ETHER_HDR_LEN + sizeof(struct ip) - 1);
 
-	TXD->upper_setup.tcp_fields.tucss = 
+	TXD->upper_setup.tcp_fields.tucss =
 		ETHER_HDR_LEN + sizeof(struct ip);
 	TXD->upper_setup.tcp_fields.tucse = htole16(0);
 
 	if (adapter->active_checksum_context == OFFLOAD_TCP_IP) {
-		TXD->upper_setup.tcp_fields.tucso = 
-			ETHER_HDR_LEN + sizeof(struct ip) + 
+		TXD->upper_setup.tcp_fields.tucso =
+			ETHER_HDR_LEN + sizeof(struct ip) +
 			offsetof(struct tcphdr, th_sum);
 	} else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) {
-		TXD->upper_setup.tcp_fields.tucso = 
-			ETHER_HDR_LEN + sizeof(struct ip) + 
+		TXD->upper_setup.tcp_fields.tucso =
+			ETHER_HDR_LEN + sizeof(struct ip) +
 			offsetof(struct udphdr, uh_sum);
 	}
 
@@ -2769,7 +2739,7 @@ em_clean_transmit_interrupts(struct adapter * adapter)
          * If there are no pending descriptors, clear the timeout. Otherwise,
          * if some descriptors have been freed, restart the timeout.
          */
-        if (num_avail > EM_TX_CLEANUP_THRESHOLD) {                
+        if (num_avail > EM_TX_CLEANUP_THRESHOLD) {
                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
                 if (num_avail == adapter->num_tx_desc)
                         ifp->if_timer = 0;
@@ -2786,60 +2756,55 @@ em_clean_transmit_interrupts(struct adapter * adapter)
  *
  **********************************************************************/
 static int
-em_get_buf(int i, struct adapter *adapter,
-           struct mbuf *nmp)
-{
-        struct mbuf    *mp = nmp;
-        struct em_buffer *rx_buffer;
-        struct ifnet   *ifp;
-	bus_dma_segment_t segs[1];
-	int error, nsegs;
-
-        ifp = adapter->ifp;
-
-        if (mp == NULL) {
-                mp = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
-                if (mp == NULL) {
-                        adapter->mbuf_cluster_failed++;
-                        return(ENOBUFS);
-                }
-                mp->m_len = mp->m_pkthdr.len = MCLBYTES;
-        } else {
-                mp->m_len = mp->m_pkthdr.len = MCLBYTES;
-                mp->m_data = mp->m_ext.ext_buf;
-                mp->m_next = NULL;
-        }
+em_get_buf(int i, struct adapter *adapter, struct mbuf *mp)
+{
+	struct ifnet		*ifp = adapter->ifp;
+	bus_dma_segment_t	segs[1];
+	struct em_buffer	*rx_buffer;
+	int			error, nsegs;
+
+	if (mp == NULL) {
+		mp = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
+		if (mp == NULL) {
+			adapter->mbuf_cluster_failed++;
+			return(ENOBUFS);
+		}
+		mp->m_len = mp->m_pkthdr.len = MCLBYTES;
+	} else {
+		mp->m_len = mp->m_pkthdr.len = MCLBYTES;
+		mp->m_data = mp->m_ext.ext_buf;
+		mp->m_next = NULL;
+	}
 
-        if (ifp->if_mtu <= ETHERMTU) {
+	if (ifp->if_mtu <= ETHERMTU)
                 m_adj(mp, ETHER_ALIGN);
-        }
 
-        rx_buffer = &adapter->rx_buffer_area[i];
+	rx_buffer = &adapter->rx_buffer_area[i];
 
-        /*
-         * Using memory from the mbuf cluster pool, invoke the
-         * bus_dma machinery to arrange the memory mapping.
-         */
-        error = bus_dmamap_load_mbuf_sg(adapter->rxtag, rx_buffer->map,
+	/*
+	 * Using memory from the mbuf cluster pool, invoke the
+	 * bus_dma machinery to arrange the memory mapping.
+	 */
+	error = bus_dmamap_load_mbuf_sg(adapter->rxtag, rx_buffer->map,
 	    mp, segs, &nsegs, 0);
-        if (error != 0) {
-                m_free(mp);
-                return(error);
-        }
-	/* If nsegs is wrong then the stack is corrupt */
+	if (error != 0) {
+		m_free(mp);
+		return (error);
+	}
+	/* If nsegs is wrong then the stack is corrupt. */
 	KASSERT(nsegs == 1, ("Too many segments returned!"));
-        rx_buffer->m_head = mp;
-        adapter->rx_desc_base[i].buffer_addr = htole64(segs[0].ds_addr);
-        bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD);
+	rx_buffer->m_head = mp;
+	adapter->rx_desc_base[i].buffer_addr = htole64(segs[0].ds_addr);
+	bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD);
 
-        return(0);
+	return(0);
 }
 
 /*********************************************************************
  *
- *  Allocate memory for rx_buffer structures. Since we use one 
- *  rx_buffer per received packet, the maximum number of rx_buffer's 
- *  that we'll need is equal to the number of receive descriptors 
+ *  Allocate memory for rx_buffer structures. Since we use one
+ *  rx_buffer per received packet, the maximum number of rx_buffer's
+ *  that we'll need is equal to the number of receive descriptors
  *  that we've allocated.
  *
  **********************************************************************/
@@ -2910,7 +2875,7 @@ fail:
 /*********************************************************************
  *
  *  Allocate and initialize receive structures.
- *  
+ *
  **********************************************************************/
 static int
 em_setup_receive_structures(struct adapter * adapter)
@@ -2929,7 +2894,7 @@ em_setup_receive_structures(struct adapter * adapter)
 /*********************************************************************
  *
  *  Enable receive unit.
- *  
+ *
  **********************************************************************/
 static void
 em_initialize_receive_unit(struct adapter * adapter)
@@ -2946,7 +2911,7 @@ em_initialize_receive_unit(struct adapter * adapter)
 	E1000_WRITE_REG(&adapter->hw, RCTL, 0);
 
 	/* Set the Receive Delay Timer Register */
-	E1000_WRITE_REG(&adapter->hw, RDTR, 
+	E1000_WRITE_REG(&adapter->hw, RDTR,
 			adapter->rx_int_delay.value | E1000_RDT_FPDB);
 
 	if(adapter->hw.mac_type >= em_82540) {
@@ -2958,7 +2923,7 @@ em_initialize_receive_unit(struct adapter * adapter)
 #define MAX_INTS_PER_SEC        8000
 #define DEFAULT_ITR             1000000000/(MAX_INTS_PER_SEC * 256)
                 E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR);
-        }       
+        }
 
 	/* Setup the Base and Length of the Rx Descriptor Ring */
 	bus_addr = adapter->rxdma.dma_paddr;
@@ -2987,7 +2952,7 @@ em_initialize_receive_unit(struct adapter * adapter)
 		break;
 	case EM_RXBUFFER_4096:
 		reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
-		break;            
+		break;
 	case EM_RXBUFFER_8192:
 		reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
 		break;
@@ -3000,7 +2965,7 @@ em_initialize_receive_unit(struct adapter * adapter)
 		reg_rctl |= E1000_RCTL_LPE;
 
 	/* Enable 82543 Receive Checksum Offload for TCP and UDP */
-	if ((adapter->hw.mac_type >= em_82543) && 
+	if ((adapter->hw.mac_type >= em_82543) &&
 	    (ifp->if_capenable & IFCAP_RXCSUM)) {
 		reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM);
 		reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL);
@@ -3070,29 +3035,28 @@ em_free_receive_structures(struct adapter *adapter)
 static int
 em_process_receive_interrupts(struct adapter * adapter, int count)
 {
-	struct ifnet        *ifp;
-	struct mbuf         *mp;
-	u_int8_t            accept_frame = 0;
- 	u_int8_t            eop = 0;
-	u_int16_t           len, desc_len, prev_len_adj;
-	int                 i;
+	struct ifnet	*ifp;
+	struct mbuf	*mp;
+	uint8_t		accept_frame = 0;
+	uint8_t		eop = 0;
+	uint16_t 	len, desc_len, prev_len_adj;
+	int		i;
 
 	/* Pointer to the receive descriptor being examined. */
 	struct em_rx_desc   *current_desc;
 
 	ifp = adapter->ifp;
 	i = adapter->next_rx_desc_to_check;
-        current_desc = &adapter->rx_desc_base[i];
+	current_desc = &adapter->rx_desc_base[i];
 	bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
 	    BUS_DMASYNC_POSTREAD);
 
-	if (!((current_desc->status) & E1000_RXD_STAT_DD)) {
+	if (!((current_desc->status) & E1000_RXD_STAT_DD))
 		return (0);
-	}
 
 	while ((current_desc->status & E1000_RXD_STAT_DD) &&
-		    (count != 0) &&
-		    (ifp->if_drv_flags & IFF_DRV_RUNNING)) {
+	    (count != 0) &&
+	    (ifp->if_drv_flags & IFF_DRV_RUNNING)) {
 		struct mbuf *m = NULL;
 
 		mp = adapter->rx_buffer_area[i].m_head;
@@ -3103,51 +3067,45 @@ em_process_receive_interrupts(struct adapter * adapter, int count)
 
 		accept_frame = 1;
 		prev_len_adj = 0;
-                desc_len = le16toh(current_desc->length);
+		desc_len = le16toh(current_desc->length);
 		if (current_desc->status & E1000_RXD_STAT_EOP) {
 			count--;
 			eop = 1;
 			if (desc_len < ETHER_CRC_LEN) {
-                                len = 0;
-                                prev_len_adj = ETHER_CRC_LEN - desc_len;
-                        }
-                        else {
-                                len = desc_len - ETHER_CRC_LEN;
-                        }
+				len = 0;
+				prev_len_adj = ETHER_CRC_LEN - desc_len;
+			} else
+				len = desc_len - ETHER_CRC_LEN;
 		} else {
 			eop = 0;
 			len = desc_len;
 		}
 
 		if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
-			u_int8_t            last_byte;
-			u_int32_t           pkt_len = desc_len;
+			uint8_t		last_byte;
+			uint32_t	pkt_len = desc_len;
 
 			if (adapter->fmp != NULL)
-				pkt_len += adapter->fmp->m_pkthdr.len; 
- 
-			last_byte = *(mtod(mp, caddr_t) + desc_len - 1);			
+				pkt_len += adapter->fmp->m_pkthdr.len;
 
-			if (TBI_ACCEPT(&adapter->hw, current_desc->status, 
-				       current_desc->errors, 
-				       pkt_len, last_byte)) {
-				em_tbi_adjust_stats(&adapter->hw, 
-						    &adapter->stats, 
-						    pkt_len, 
-						    adapter->hw.mac_addr);
-				if (len > 0) len--;
-			} 
-			else {
+			last_byte = *(mtod(mp, caddr_t) + desc_len - 1);			
+			if (TBI_ACCEPT(&adapter->hw, current_desc->status,
+			    current_desc->errors,
+			    pkt_len, last_byte)) {
+				em_tbi_adjust_stats(&adapter->hw,
+				    &adapter->stats, pkt_len,
+				    adapter->hw.mac_addr);
+				if (len > 0)
+					len--;
+			} else
 				accept_frame = 0;
-			}
 		}
 
 		if (accept_frame) {
-
 			if (em_get_buf(i, adapter, NULL) == ENOBUFS) {
 				adapter->dropped_pkts++;
 				em_get_buf(i, adapter, mp);
-				if (adapter->fmp != NULL) 
+				if (adapter->fmp != NULL)
 					m_freem(adapter->fmp);
 				adapter->fmp = NULL;
 				adapter->lmp = NULL;
@@ -3159,36 +3117,37 @@ em_process_receive_interrupts(struct adapter * adapter, int count)
 
 			if (adapter->fmp == NULL) {
 				mp->m_pkthdr.len = len;
-				adapter->fmp = mp;	 /* Store the first mbuf */
+				adapter->fmp = mp; /* Store the first mbuf */
 				adapter->lmp = mp;
 			} else {
 				/* Chain mbuf's together */
 				mp->m_flags &= ~M_PKTHDR;
-				/* 
-                                 * Adjust length of previous mbuf in chain if we 
-                                 * received less than 4 bytes in the last descriptor.
-                                 */
+				/*
+				 * Adjust length of previous mbuf in chain if
+				 * we received less than 4 bytes in the last
+				 * descriptor.
+				 */
 				if (prev_len_adj > 0) {
 					adapter->lmp->m_len -= prev_len_adj;
-					adapter->fmp->m_pkthdr.len -= prev_len_adj;
+					adapter->fmp->m_pkthdr.len -=
+					    prev_len_adj;
 				}
 				adapter->lmp->m_next = mp;
 				adapter->lmp = adapter->lmp->m_next;
 				adapter->fmp->m_pkthdr.len += len;
 			}
 
-                        if (eop) {
-                                adapter->fmp->m_pkthdr.rcvif = ifp;
+			if (eop) {
+				adapter->fmp->m_pkthdr.rcvif = ifp;
 				ifp->if_ipackets++;
-                                em_receive_checksum(adapter, current_desc,
-                                                    adapter->fmp);
+				em_receive_checksum(adapter, current_desc,
+				    adapter->fmp);
 #ifndef __NO_STRICT_ALIGNMENT
 				if (ifp->if_mtu > ETHERMTU &&
 				    em_fixup_rx(adapter) != 0)
 					goto skip;
-
 #endif
-                                if (current_desc->status & E1000_RXD_STAT_VP)
+				if (current_desc->status & E1000_RXD_STAT_VP)
 					VLAN_INPUT_TAG(ifp, adapter->fmp,
 					    (le16toh(current_desc->special) &
 					    E1000_RXD_SPC_VLAN_MASK));
@@ -3198,22 +3157,22 @@ skip:
 				m = adapter->fmp;
 				adapter->fmp = NULL;
 				adapter->lmp = NULL;
-                        }
+			}
 		} else {
 			adapter->dropped_pkts++;
 			em_get_buf(i, adapter, mp);
-			if (adapter->fmp != NULL) 
+			if (adapter->fmp != NULL)
 				m_freem(adapter->fmp);
 			adapter->fmp = NULL;
 			adapter->lmp = NULL;
 		}
 
-		/* Zero out the receive descriptors status  */
+		/* Zero out the receive descriptors status. */
 		current_desc->status = 0;
 		bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
 		    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
- 
-                /* Advance our pointers to the next descriptor */
+
+		/* Advance our pointers to the next descriptor. */
 		if (++i == adapter->num_rx_desc)
 			i = 0;
 		if (m != NULL) {
@@ -3226,12 +3185,12 @@ skip:
 	adapter->next_rx_desc_to_check = i;
 
 	/* Advance the E1000's Receive Queue #0  "Tail Pointer". */
-	if (--i < 0) i = adapter->num_rx_desc - 1;
+	if (--i < 0)
+		i = adapter->num_rx_desc - 1;
 	E1000_WRITE_REG(&adapter->hw, RDT, i);
-
-	if (!((current_desc->status) & E1000_RXD_STAT_DD)) {
+	if (!((current_desc->status) & E1000_RXD_STAT_DD))
 		return (0);
-	}
+
 	return (1);
 }
 
@@ -3242,7 +3201,7 @@ skip:
  * as it nullifies DMA operations. 8254x just allows RX buffer size to be
  * 2048/4096/8192/16384. What we really want is 2048 - ETHER_ALIGN to align its
  * payload. On architecures without strict alignment restrictions 8254x still
- * performs unaligned memory access which would reduce the performance too. 
+ * performs unaligned memory access which would reduce the performance too.
  * To avoid copying over an entire frame to align, we allocate a new mbuf and
  * copy ethernet header to the new mbuf. The new mbuf is prepended into the
  * existing mbuf chain.
@@ -3285,7 +3244,7 @@ em_fixup_rx(struct adapter *adapter)
 
 /*********************************************************************
  *
- *  Verify that the hardware indicated that the checksum is valid. 
+ *  Verify that the hardware indicated that the checksum is valid.
  *  Inform the stack about the status of checksum so that stack
  *  doesn't spend time verifying the checksum.
  *
@@ -3316,9 +3275,9 @@ em_receive_checksum(struct adapter *adapter,
 	}
 
 	if (rx_desc->status & E1000_RXD_STAT_TCPCS) {
-		/* Did it pass? */        
+		/* Did it pass? */
 		if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) {
-			mp->m_pkthdr.csum_flags |= 
+			mp->m_pkthdr.csum_flags |=
 			(CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
 			mp->m_pkthdr.csum_data = htons(0xffff);
 		}
@@ -3328,7 +3287,7 @@ em_receive_checksum(struct adapter *adapter,
 }
 
 
-static void 
+static void
 em_enable_vlans(struct adapter *adapter)
 {
 	uint32_t ctrl;
@@ -3336,7 +3295,7 @@ em_enable_vlans(struct adapter *adapter)
 	E1000_WRITE_REG(&adapter->hw, VET, ETHERTYPE_VLAN);
 
 	ctrl = E1000_READ_REG(&adapter->hw, CTRL);
-	ctrl |= E1000_CTRL_VME; 
+	ctrl |= E1000_CTRL_VME;
 	E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
 
 	return;
@@ -3365,11 +3324,12 @@ static void
 em_disable_intr(struct adapter *adapter)
 {
 	/*
-	 * The first version of 82542 had an errata where when link was forced it
-	 * would stay up even up even if the cable was disconnected.  Sequence errors
-	 * were used to detect the disconnect and then the driver would unforce the link.
-	 * This code in the in the ISR.  For this to work correctly the Sequence error 
-	 * interrupt had to be enabled all the time.
+	 * The first version of 82542 had an errata where when link was forced
+	 * it would stay up even up even if the cable was disconnected.
+	 * Sequence errors were used to detect the disconnect and then the
+	 * driver would unforce the link. This code in the in the ISR. For this
+	 * to work correctly the Sequence error interrupt had to be enabled
+	 * all the time.
 	 */
 
 	if (adapter->hw.mac_type == em_82542_rev2_0)
@@ -3385,7 +3345,7 @@ static int
 em_is_valid_ether_addr(u_int8_t *addr)
 {
         char zero_addr[6] = { 0, 0, 0, 0, 0, 0 };
-                                
+
         if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) {
                 return (FALSE);
         }
@@ -3393,16 +3353,16 @@ em_is_valid_ether_addr(u_int8_t *addr)
         return(TRUE);
 }
 
-void 
+void
 em_write_pci_cfg(struct em_hw *hw,
 		      uint32_t reg,
 		      uint16_t *value)
 {
-	pci_write_config(((struct em_osdep *)hw->back)->dev, reg, 
+	pci_write_config(((struct em_osdep *)hw->back)->dev, reg,
 			 *value, 2);
 }
 
-void 
+void
 em_read_pci_cfg(struct em_hw *hw, uint32_t reg,
 		     uint16_t *value)
 {
@@ -3473,7 +3433,7 @@ em_fill_descriptors (bus_addr_t address,
                 desc_array->elements = 1;
                 return desc_array->elements;
         }
-         
+
         desc_array->descriptor[0].address = address;
         desc_array->descriptor[0].length = length - 4;
         desc_array->descriptor[1].address = address + (length - 4);
@@ -3484,7 +3444,7 @@ em_fill_descriptors (bus_addr_t address,
 
 /**********************************************************************
  *
- *  Update the board statistics counters. 
+ *  Update the board statistics counters.
  *
  **********************************************************************/
 static void
@@ -3526,7 +3486,7 @@ em_update_stats_counters(struct adapter *adapter)
 	/* For the 64-bit byte counters the low dword must be read first. */
 	/* Both registers clear on the read of the high dword */
 
-	adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL); 
+	adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL);
 	adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH);
 	adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL);
 	adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH);
@@ -3554,17 +3514,17 @@ em_update_stats_counters(struct adapter *adapter)
 	adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC);
 
 	if (adapter->hw.mac_type >= em_82543) {
-		adapter->stats.algnerrc += 
+		adapter->stats.algnerrc +=
 		E1000_READ_REG(&adapter->hw, ALGNERRC);
-		adapter->stats.rxerrc += 
+		adapter->stats.rxerrc +=
 		E1000_READ_REG(&adapter->hw, RXERRC);
-		adapter->stats.tncrs += 
+		adapter->stats.tncrs +=
 		E1000_READ_REG(&adapter->hw, TNCRS);
-		adapter->stats.cexterr += 
+		adapter->stats.cexterr +=
 		E1000_READ_REG(&adapter->hw, CEXTERR);
-		adapter->stats.tsctc += 
+		adapter->stats.tsctc +=
 		E1000_READ_REG(&adapter->hw, TSCTC);
-		adapter->stats.tsctfc += 
+		adapter->stats.tsctfc +=
 		E1000_READ_REG(&adapter->hw, TSCTFC);
 	}
 	ifp = adapter->ifp;
@@ -3599,25 +3559,25 @@ em_print_debug_info(struct adapter *adapter)
 {
 	int unit = adapter->unit;
 	uint8_t *hw_addr = adapter->hw.hw_addr;
- 
+
 	printf("em%d: Adapter hardware address = %p \n", unit, hw_addr);
-	printf("em%d: CTRL = 0x%x RCTL = 0x%x \n", unit, 
+	printf("em%d: CTRL = 0x%x RCTL = 0x%x \n", unit,
 	    E1000_READ_REG(&adapter->hw, CTRL),
-	    E1000_READ_REG(&adapter->hw, RCTL)); 
-	printf("em%d: Packet buffer = Tx=%dk Rx=%dk \n", unit, 
+	    E1000_READ_REG(&adapter->hw, RCTL));
+	printf("em%d: Packet buffer = Tx=%dk Rx=%dk \n", unit,
 	    ((E1000_READ_REG(&adapter->hw, PBA) & 0xffff0000) >> 16),\
 	    (E1000_READ_REG(&adapter->hw, PBA) & 0xffff) );
-	printf("em%d: Flow control watermarks high = %d low = %d\n", unit, 
+	printf("em%d: Flow control watermarks high = %d low = %d\n", unit,
 	    adapter->hw.fc_high_water,
 	    adapter->hw.fc_low_water);
-	printf("em%d: tx_int_delay = %d, tx_abs_int_delay = %d\n", unit, 
+	printf("em%d: tx_int_delay = %d, tx_abs_int_delay = %d\n", unit,
 	    E1000_READ_REG(&adapter->hw, TIDV),
 	    E1000_READ_REG(&adapter->hw, TADV));
-	printf("em%d: rx_int_delay = %d, rx_abs_int_delay = %d\n", unit, 
+	printf("em%d: rx_int_delay = %d, rx_abs_int_delay = %d\n", unit,
 	    E1000_READ_REG(&adapter->hw, RDTR),
 	    E1000_READ_REG(&adapter->hw, RADV));
 	printf("em%d: fifo workaround = %lld, fifo_reset_count = %lld\n",
-	    unit, (long long)adapter->tx_fifo_wrk_cnt, 
+	    unit, (long long)adapter->tx_fifo_wrk_cnt,
 	    (long long)adapter->tx_fifo_reset_cnt);
 	printf("em%d: hw tdh = %d, hw tdt = %d\n", unit,
 	    E1000_READ_REG(&adapter->hw, TDH),