Added support for 82540EM based cards.

Cosmetic changes to make code more unix-like.

MFC after:	1 week

7 files changed, 1107 insertions, 1011 deletions

diff --git a/sys/dev/em/if_em.c b/sys/dev/em/if_em.c
index a666dd4..e641037 100644
--- a/sys/dev/em/if_em.c
+++ b/sys/dev/em/if_em.c
@@ -1,6 +1,6 @@
 /**************************************************************************
 
-Copyright (c) 2001 Intel Corporation
+Copyright (c) 2001-2002 Intel Corporation
 All rights reserved.
 
 Redistribution and use in source and binary forms of the Software, with or
@@ -53,7 +53,7 @@ struct adapter *em_adapter_list = NULL;
  *  Driver version
  *********************************************************************/
 
-char em_driver_version[] = "1.1.10";
+char em_driver_version[] = "1.2.7";
 
 
 /*********************************************************************
@@ -75,6 +75,7 @@ static em_vendor_info_t em_vendor_info_array[] =
     { 0x8086, 0x1009, PCI_ANY_ID, PCI_ANY_ID, 0 },
     { 0x8086, 0x100C, PCI_ANY_ID, PCI_ANY_ID, 0 },
     { 0x8086, 0x100D, PCI_ANY_ID, PCI_ANY_ID, 0 },
+    { 0x8086, 0x100E, PCI_ANY_ID, PCI_ANY_ID, 0 },
     /* required last entry */
     { 0, 0, 0, 0, 0}
 };
@@ -91,52 +92,53 @@ static char *em_strings[] = {
 /*********************************************************************
  *  Function prototypes            
  *********************************************************************/
-static int em_probe(device_t);
-static int em_attach(device_t);
-static int em_detach(device_t);
-static int em_shutdown(device_t);
+static int  em_probe(device_t);
+static int  em_attach(device_t);
+static int  em_detach(device_t);
+static int  em_shutdown(device_t);
 static void em_intr(void *);
 static void em_start(struct ifnet *);
-static int em_ioctl(struct ifnet *, IOCTL_CMD_TYPE, caddr_t);
+static int  em_ioctl(struct ifnet *, IOCTL_CMD_TYPE, caddr_t);
 static void em_watchdog(struct ifnet *);
 static void em_init(void *);
 static void em_stop(void *);
 static void em_media_status(struct ifnet *, struct ifmediareq *);
-static int em_media_change(struct ifnet *);
+static int  em_media_change(struct ifnet *);
 static void em_identify_hardware(struct adapter *);
-static int em_allocate_pci_resources(struct adapter *);
+static int  em_allocate_pci_resources(struct adapter *);
 static void em_free_pci_resources(struct adapter *);
 static void em_local_timer(void *);
-static int em_hardware_init(struct adapter *);
+static int  em_hardware_init(struct adapter *);
 static void em_read_mac_address(struct adapter *, u_int8_t *);
 static void em_setup_interface(device_t, struct adapter *);
-static int em_setup_transmit_structures(struct adapter *);
+static int  em_setup_transmit_structures(struct adapter *);
 static void em_initialize_transmit_unit(struct adapter *);
-static int em_setup_receive_structures(struct adapter *);
+static int  em_setup_receive_structures(struct adapter *);
 static void em_initialize_receive_unit(struct adapter *);
-static void EnableInterrupts(struct adapter *);
-static void DisableInterrupts(struct adapter *);
+static void em_enable_intr(struct adapter *);
+static void em_disable_intr(struct adapter *);
 static void em_free_transmit_structures(struct adapter *);
 static void em_free_receive_structures(struct adapter *);
 static void em_update_stats_counters(struct adapter *);
 static void em_clean_transmit_interrupts(struct adapter *);
-static int em_allocate_receive_structures(struct adapter *);
-static int em_allocate_transmit_structures(struct adapter *);
+static int  em_allocate_receive_structures(struct adapter *);
+static int  em_allocate_transmit_structures(struct adapter *);
 static void em_process_receive_interrupts(struct adapter *);
 static void em_receive_checksum(struct adapter *, 
-                                     struct em_rx_desc * RxDescriptor,
-                                     struct mbuf *);
+                                struct em_rx_desc * rx_desc,
+                                struct mbuf *);
 static void em_transmit_checksum_setup(struct adapter *,
-                                            struct mbuf *,
-                                            struct em_tx_buffer *,
-                                            u_int32_t *,
-                                            u_int32_t *);
+                                       struct mbuf *,
+                                       struct em_tx_buffer *,
+                                       u_int32_t *,
+                                       u_int32_t *);
 static void em_set_promisc(struct adapter *);
 static void em_disable_promisc(struct adapter *);
 static void em_set_multi(struct adapter *);
 static void em_print_hw_stats(struct adapter *);
 static void em_print_link_status(struct adapter *);
-static int em_get_buf(struct em_rx_buffer *, struct adapter *, struct mbuf *);
+static int  em_get_buf(struct em_rx_buffer *, struct adapter *,
+                       struct mbuf *);
 /*********************************************************************
  *  FreeBSD Device Interface Entry Points                    
  *********************************************************************/
@@ -223,128 +225,128 @@ em_probe(device_t dev)
 static int
 em_attach(device_t dev)
 {
-   struct adapter * Adapter;
+   struct adapter * adapter;
    int             s;
    int             tsize, rsize;
 
    INIT_DEBUGOUT("em_attach: begin");
    s = splimp();
 
-   /* Allocate, clear, and link in our Adapter structure */
-   if (!(Adapter = device_get_softc(dev))) {
-      printf("em: Adapter structure allocation failed\n");
+   /* Allocate, clear, and link in our adapter structure */
+   if (!(adapter = device_get_softc(dev))) {
+      printf("em: adapter structure allocation failed\n");
       splx(s);
       return(ENOMEM);
    }
-   bzero(Adapter, sizeof(struct adapter ));
-   Adapter->dev = dev;
-   Adapter->osdep.dev = dev;
-   Adapter->unit = device_get_unit(dev);
+   bzero(adapter, sizeof(struct adapter ));
+   adapter->dev = dev;
+   adapter->osdep.dev = dev;
+   adapter->unit = device_get_unit(dev);
 
    if (em_adapter_list != NULL)
-      em_adapter_list->prev = Adapter;
-   Adapter->next = em_adapter_list;
-   em_adapter_list = Adapter;
+      em_adapter_list->prev = adapter;
+   adapter->next = em_adapter_list;
+   em_adapter_list = adapter;
 
-   callout_handle_init(&Adapter->timer_handle);
+   callout_handle_init(&adapter->timer_handle);
 
    /* Determine hardware revision */
-   em_identify_hardware(Adapter);
+   em_identify_hardware(adapter);
 
    /* Parameters (to be read from user) */
-   Adapter->NumTxDescriptors = MAX_TXD;
-   Adapter->NumRxDescriptors = MAX_RXD;
-   Adapter->TxIntDelay = TIDV;
-   Adapter->RxIntDelay = RIDV;
-   Adapter->shared.autoneg = DO_AUTO_NEG;
-   Adapter->shared.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT;
-   Adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT;
-   Adapter->shared.tbi_compatibility_en = TRUE;
-   Adapter->RxBufferLen = EM_RXBUFFER_2048;
-   Adapter->RxChecksum = EM_ENABLE_RXCSUM_OFFLOAD;
+   adapter->num_tx_desc = MAX_TXD;
+   adapter->num_rx_desc = MAX_RXD;
+   adapter->tx_int_delay = TIDV;
+   adapter->rx_int_delay = RIDV;
+   adapter->shared.autoneg = DO_AUTO_NEG;
+   adapter->shared.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT;
+   adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT;
+   adapter->shared.tbi_compatibility_en = TRUE;
+   adapter->rx_buffer_len = EM_RXBUFFER_2048;
+   adapter->rx_checksum = EM_ENABLE_RXCSUM_OFFLOAD;
    
-   Adapter->shared.fc_high_water = FC_DEFAULT_HI_THRESH;
-   Adapter->shared.fc_low_water  = FC_DEFAULT_LO_THRESH;
-   Adapter->shared.fc_pause_time = FC_DEFAULT_TX_TIMER;
-   Adapter->shared.fc_send_xon   = TRUE;
-   Adapter->shared.fc = em_fc_full;
-
+   adapter->shared.fc_high_water = FC_DEFAULT_HI_THRESH;
+   adapter->shared.fc_low_water  = FC_DEFAULT_LO_THRESH;
+   adapter->shared.fc_pause_time = FC_DEFAULT_TX_TIMER;
+   adapter->shared.fc_send_xon   = TRUE;
+   adapter->shared.fc = em_fc_full;
 
    /* Set the max frame size assuming standard ethernet sized frames */   
-   Adapter->shared.max_frame_size = ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN;
+   adapter->shared.max_frame_size = ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN;
+   adapter->shared.min_frame_size = MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN;
 
    /* This controls when hardware reports transmit completion status. */
    if ((EM_REPORT_TX_EARLY == 0) || (EM_REPORT_TX_EARLY == 1)) {
-      Adapter->shared.report_tx_early = EM_REPORT_TX_EARLY;
+      adapter->shared.report_tx_early = EM_REPORT_TX_EARLY;
    } else {
-      if(Adapter->shared.mac_type < em_82543) {
-         Adapter->shared.report_tx_early = 0;
+      if(adapter->shared.mac_type < em_82543) {
+         adapter->shared.report_tx_early = 0;
       } else {
-         Adapter->shared.report_tx_early = 1;
+         adapter->shared.report_tx_early = 1;
       }
    }
 
-   if (em_allocate_pci_resources(Adapter)) {
-      printf("em%d: Allocation of PCI resources failed\n", Adapter->unit);
-      em_free_pci_resources(Adapter);
+   if (em_allocate_pci_resources(adapter)) {
+      printf("em%d: Allocation of PCI resources failed\n", adapter->unit);
+      em_free_pci_resources(adapter);
       splx(s);
       return(ENXIO);
    }
 
-   tsize = EM_ROUNDUP(Adapter->NumTxDescriptors *
+   tsize = EM_ROUNDUP(adapter->num_tx_desc *
                       sizeof(struct em_tx_desc), 4096);
 
    /* Allocate Transmit Descriptor ring */
-   if (!(Adapter->TxDescBase = (struct em_tx_desc *)
+   if (!(adapter->tx_desc_base = (struct em_tx_desc *)
          contigmalloc(tsize, M_DEVBUF, M_NOWAIT, 0, ~0, PAGE_SIZE, 0))) {
-      printf("em%d: Unable to allocate TxDescriptor memory\n", Adapter->unit);
-      em_free_pci_resources(Adapter);
+      printf("em%d: Unable to allocate TxDescriptor memory\n", adapter->unit);
+      em_free_pci_resources(adapter);
       splx(s);
       return(ENOMEM);
    }
 
-   rsize = EM_ROUNDUP(Adapter->NumRxDescriptors *
+   rsize = EM_ROUNDUP(adapter->num_rx_desc *
                       sizeof(struct em_rx_desc), 4096);
 
    /* Allocate Receive Descriptor ring */
-   if (!(Adapter->RxDescBase = (struct em_rx_desc *)
+   if (!(adapter->rx_desc_base = (struct em_rx_desc *)
         contigmalloc(rsize, M_DEVBUF, M_NOWAIT, 0, ~0, PAGE_SIZE, 0))) {
-      printf("em%d: Unable to allocate RxDescriptor memory\n", Adapter->unit);
-      em_free_pci_resources(Adapter);
-      contigfree(Adapter->TxDescBase, tsize, M_DEVBUF);
+      printf("em%d: Unable to allocate rx_desc memory\n", adapter->unit);
+      em_free_pci_resources(adapter);
+      contigfree(adapter->tx_desc_base, tsize, M_DEVBUF);
       splx(s);
       return(ENOMEM);
    }
 
    /* Initialize the hardware */
-   if (em_hardware_init(Adapter)) {
-      printf("em%d: Unable to initialize the hardware\n",Adapter->unit);
-      em_free_pci_resources(Adapter);
-      contigfree(Adapter->TxDescBase, tsize, M_DEVBUF);
-      contigfree(Adapter->RxDescBase, rsize, M_DEVBUF);
+   if (em_hardware_init(adapter)) {
+      printf("em%d: Unable to initialize the hardware\n",adapter->unit);
+      em_free_pci_resources(adapter);
+      contigfree(adapter->tx_desc_base, tsize, M_DEVBUF);
+      contigfree(adapter->rx_desc_base, rsize, M_DEVBUF);
       splx(s);
       return(EIO);
    }
 
    /* Setup OS specific network interface */
-   em_setup_interface(dev, Adapter);
+   em_setup_interface(dev, adapter);
 
    /* Initialize statistics */
-   em_clear_hw_cntrs(&Adapter->shared);
-   em_update_stats_counters(Adapter);
-   Adapter->shared.get_link_status = 1;
-   em_check_for_link(&Adapter->shared);
+   em_clear_hw_cntrs(&adapter->shared);
+   em_update_stats_counters(adapter);
+   adapter->shared.get_link_status = 1;
+   em_check_for_link(&adapter->shared);
 
    /* Print the link status */
-   if (Adapter->LinkIsActive == 1) {
-      em_get_speed_and_duplex(&Adapter->shared, &Adapter->LineSpeed, &Adapter->FullDuplex);
+   if (adapter->link_active == 1) {
+      em_get_speed_and_duplex(&adapter->shared, &adapter->link_speed, &adapter->link_duplex);
       printf("em%d:  Speed:%d Mbps  Duplex:%s\n",
-             Adapter->unit,
-             Adapter->LineSpeed,
-             Adapter->FullDuplex == FULL_DUPLEX ? "Full" : "Half");
+             adapter->unit,
+             adapter->link_speed,
+             adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half");
    }
    else
-      printf("em%d:  Speed:N/A  Duplex:N/A\n", Adapter->unit);
+      printf("em%d:  Speed:N/A  Duplex:N/A\n", adapter->unit);
 
 
    INIT_DEBUGOUT("em_attach: end");
@@ -365,44 +367,44 @@ em_attach(device_t dev)
 static int
 em_detach(device_t dev)
 {
-   struct adapter * Adapter = device_get_softc(dev);
-   struct ifnet   *ifp = &Adapter->interface_data.ac_if;
+   struct adapter * adapter = device_get_softc(dev);
+   struct ifnet   *ifp = &adapter->interface_data.ac_if;
    int             s;
    int             size;
 
    INIT_DEBUGOUT("em_detach: begin");
    s = splimp();
 
-   em_stop(Adapter);
-   em_phy_hw_reset(&Adapter->shared);
-   ether_ifdetach(&Adapter->interface_data.ac_if, ETHER_BPF_SUPPORTED);
-   em_free_pci_resources(Adapter);
+   em_stop(adapter);
+   em_phy_hw_reset(&adapter->shared);
+   ether_ifdetach(&adapter->interface_data.ac_if, ETHER_BPF_SUPPORTED);
+   em_free_pci_resources(adapter);
 
-   size = EM_ROUNDUP(Adapter->NumTxDescriptors *
+   size = EM_ROUNDUP(adapter->num_tx_desc *
                      sizeof(struct em_tx_desc), 4096);
 
    /* Free Transmit Descriptor ring */
-   if (Adapter->TxDescBase) {
-      contigfree(Adapter->TxDescBase, size, M_DEVBUF);
-      Adapter->TxDescBase = NULL;
+   if (adapter->tx_desc_base) {
+      contigfree(adapter->tx_desc_base, size, M_DEVBUF);
+      adapter->tx_desc_base = NULL;
    }
 
-   size = EM_ROUNDUP(Adapter->NumRxDescriptors *
+   size = EM_ROUNDUP(adapter->num_rx_desc *
                      sizeof(struct em_rx_desc), 4096);
 
    /* Free Receive Descriptor ring */
-   if (Adapter->RxDescBase) {
-      contigfree(Adapter->RxDescBase, size, M_DEVBUF);
-      Adapter->RxDescBase = NULL;
+   if (adapter->rx_desc_base) {
+      contigfree(adapter->rx_desc_base, size, M_DEVBUF);
+      adapter->rx_desc_base = NULL;
    }
 
    /* Remove from the adapter list */
-   if(em_adapter_list == Adapter)
-      em_adapter_list = Adapter->next;
-   if(Adapter->next != NULL)
-      Adapter->next->prev = Adapter->prev;
-   if(Adapter->prev != NULL)
-      Adapter->prev->next = Adapter->next;
+   if(em_adapter_list == adapter)
+      em_adapter_list = adapter->next;
+   if(adapter->next != NULL)
+      adapter->next->prev = adapter->prev;
+   if(adapter->prev != NULL)
+      adapter->prev->next = adapter->next;
 
    ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
    ifp->if_timer = 0;
@@ -414,10 +416,10 @@ em_detach(device_t dev)
 static int
 em_shutdown(device_t dev)
 {
-   struct adapter * Adapter = device_get_softc(dev);
+   struct adapter * adapter = device_get_softc(dev);
    
    /* Issue a global reset */
-   em_adapter_stop(&Adapter->shared);
+   em_adapter_stop(&adapter->shared);
    return(0);
 }
 
@@ -436,18 +438,15 @@ static void
 em_start(struct ifnet *ifp)
 {
    int             s;
-   struct em_tx_buffer   *tx_buffer;
-   struct mbuf    *m_head;
-   struct mbuf    *mp;
-   vm_offset_t     VirtualAddress;
+   struct mbuf    *m_head, *mp;
+   vm_offset_t     virtual_addr;
    u_int32_t       txd_upper; 
    u_int32_t       txd_lower;
-   struct em_tx_desc * CurrentTxDescriptor = NULL;
-   struct adapter * Adapter = ifp->if_softc;
-
-   TXRX_DEBUGOUT("em_start: begin");   
+   struct em_tx_buffer   *tx_buffer;
+   struct em_tx_desc *current_tx_desc = NULL;
+   struct adapter * adapter = ifp->if_softc;
 
-   if (!Adapter->LinkIsActive)
+   if (!adapter->link_active)
       return;
 
    s = splimp();      
@@ -457,45 +456,41 @@ em_start(struct ifnet *ifp)
       
       if(m_head == NULL) break;
 
-      if (Adapter->NumTxDescriptorsAvail <= TX_CLEANUP_THRESHOLD)
-         em_clean_transmit_interrupts(Adapter);
+      if (adapter->num_tx_desc_avail <= TX_CLEANUP_THRESHOLD)
+         em_clean_transmit_interrupts(adapter);
 
-      if (Adapter->NumTxDescriptorsAvail <= TX_CLEANUP_THRESHOLD) {
+      if (adapter->num_tx_desc_avail <= TX_CLEANUP_THRESHOLD) {
          ifp->if_flags |= IFF_OACTIVE;
          IF_PREPEND(&ifp->if_snd, m_head);
-#ifdef DBG_STATS
-         Adapter->NoTxDescAvail++;
-#endif
+         adapter->no_tx_desc_avail++;
          break;
       }
 
-      tx_buffer =  STAILQ_FIRST(&Adapter->FreeSwTxPacketList);
+      tx_buffer =  STAILQ_FIRST(&adapter->free_tx_buffer_list);
       if (!tx_buffer) {
-#ifdef DBG_STATS
-         Adapter->NoTxBufferAvail1++;
-#endif
+         adapter->no_tx_buffer_avail1++;
+         
          /* 
           * OK so we should not get here but I've seen it so lets try to 
           * clean up and then try to get a SwPacket again and only break 
           * if we still don't get one 
           */
-         em_clean_transmit_interrupts(Adapter);
-         tx_buffer = STAILQ_FIRST(&Adapter->FreeSwTxPacketList);
+         em_clean_transmit_interrupts(adapter);
+         tx_buffer = STAILQ_FIRST(&adapter->free_tx_buffer_list);
          if (!tx_buffer) {
             ifp->if_flags |= IFF_OACTIVE;
             IF_PREPEND(&ifp->if_snd, m_head);
-#ifdef DBG_STATS
-            Adapter->NoTxBufferAvail2++;
-#endif
+            adapter->no_tx_buffer_avail2++;
             break;
          }
       }
-      STAILQ_REMOVE_HEAD(&Adapter->FreeSwTxPacketList, em_tx_entry);
-      tx_buffer->NumTxDescriptorsUsed = 0;
-      tx_buffer->Packet = m_head;
+      STAILQ_REMOVE_HEAD(&adapter->free_tx_buffer_list, em_tx_entry);
+
+      tx_buffer->num_tx_desc_used = 0;
+      tx_buffer->m_head = m_head;
 
       if (ifp->if_hwassist > 0) {
-         em_transmit_checksum_setup(Adapter,  m_head, tx_buffer, &txd_upper, &txd_lower);
+         em_transmit_checksum_setup(adapter,  m_head, tx_buffer, &txd_upper, &txd_lower);
       } else {
          txd_upper = 0;
          txd_lower = 0;
@@ -504,30 +499,31 @@ em_start(struct ifnet *ifp)
       for (mp = m_head; mp != NULL; mp = mp->m_next) {
          if (mp->m_len == 0)
             continue;
-         CurrentTxDescriptor = Adapter->NextAvailTxDescriptor;
-         VirtualAddress = mtod(mp, vm_offset_t);
-         CurrentTxDescriptor->buffer_addr = vtophys(VirtualAddress);
-
-         CurrentTxDescriptor->lower.data = (txd_lower | mp->m_len);
-         CurrentTxDescriptor->upper.data = (txd_upper);
+         current_tx_desc = adapter->next_avail_tx_desc;
+         virtual_addr = mtod(mp, vm_offset_t);
+         current_tx_desc->buffer_addr = vtophys(virtual_addr);
+ 
+         current_tx_desc->lower.data = (txd_lower | mp->m_len);
+         current_tx_desc->upper.data = (txd_upper);
 
-         if (CurrentTxDescriptor == Adapter->LastTxDescriptor)
-            Adapter->NextAvailTxDescriptor =
-            Adapter->FirstTxDescriptor;
+         if (current_tx_desc == adapter->last_tx_desc)
+            adapter->next_avail_tx_desc =
+            adapter->first_tx_desc;
          else
-            Adapter->NextAvailTxDescriptor++;
+            adapter->next_avail_tx_desc++;
 
-         Adapter->NumTxDescriptorsAvail--;
-         tx_buffer->NumTxDescriptorsUsed++;
+         adapter->num_tx_desc_avail--;
+         tx_buffer->num_tx_desc_used++;
       }
+
       /* Put this tx_buffer at the end in the "in use" list */
-      STAILQ_INSERT_TAIL(&Adapter->UsedSwTxPacketList, tx_buffer, em_tx_entry);
+      STAILQ_INSERT_TAIL(&adapter->used_tx_buffer_list, tx_buffer, em_tx_entry);
 
       /* 
        * Last Descriptor of Packet needs End Of Packet (EOP), Report Status
        * (RS) and append Ethernet CRC (IFCS) bits set.
        */
-      CurrentTxDescriptor->lower.data |= (Adapter->TxdCmd | E1000_TXD_CMD_EOP);
+      current_tx_desc->lower.data |= (adapter->txd_cmd | E1000_TXD_CMD_EOP);
 
       /* Send a copy of the frame to the BPF listener */
       if (ifp->if_bpf)
@@ -536,8 +532,8 @@ em_start(struct ifnet *ifp)
        * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000
        * that this frame is available to transmit.
        */
-      E1000_WRITE_REG(&Adapter->shared, TDT, (((u_int32_t) Adapter->NextAvailTxDescriptor -
-                             (u_int32_t) Adapter->FirstTxDescriptor) >> 4));
+      E1000_WRITE_REG(&adapter->shared, TDT, (((u_int32_t) adapter->next_avail_tx_desc -
+                             (u_int32_t) adapter->first_tx_desc) >> 4));
    } /* end of while loop */
 
    splx(s);
@@ -560,10 +556,9 @@ em_start(struct ifnet *ifp)
 static int
 em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data)
 {
-   int             s,
-                   error = 0;
+   int             s, mask, error = 0;
    struct ifreq   *ifr = (struct ifreq *) data;
-   struct adapter * Adapter = ifp->if_softc;
+   struct adapter * adapter = ifp->if_softc;
 
    s = splimp();
    switch (command) {
@@ -578,8 +573,8 @@ em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data)
          error = EINVAL;
       } else {
          ifp->if_mtu = ifr->ifr_mtu;
-         Adapter->shared.max_frame_size = ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
-         em_init(Adapter);
+         adapter->shared.max_frame_size = ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
+         em_init(adapter);
       }
       break;
    case SIOCSIFFLAGS:
@@ -587,15 +582,15 @@ em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data)
       if (ifp->if_flags & IFF_UP) {
          if (ifp->if_flags & IFF_RUNNING &&
              ifp->if_flags & IFF_PROMISC) {
-            em_set_promisc(Adapter);
+            em_set_promisc(adapter);
          } else if (ifp->if_flags & IFF_RUNNING &&
                     !(ifp->if_flags & IFF_PROMISC)) {
-            em_disable_promisc(Adapter);
+            em_disable_promisc(adapter);
          } else
-            em_init(Adapter);
+            em_init(adapter);
       } else {
          if (ifp->if_flags & IFF_RUNNING) {
-            em_stop(Adapter);
+            em_stop(adapter);
          }
       }
       break;
@@ -603,17 +598,29 @@ em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data)
    case SIOCDELMULTI:
       IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI");
       if (ifp->if_flags & IFF_RUNNING) {
-         DisableInterrupts(Adapter);
-         em_set_multi(Adapter);
-         if(Adapter->shared.mac_type == em_82542_rev2_0)
-            em_initialize_receive_unit(Adapter);
-         EnableInterrupts(Adapter);
+         em_disable_intr(adapter);
+         em_set_multi(adapter);
+         if(adapter->shared.mac_type == em_82542_rev2_0)
+            em_initialize_receive_unit(adapter);
+         em_enable_intr(adapter);
       }
       break;
    case SIOCSIFMEDIA:
    case SIOCGIFMEDIA:
       IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)");
-      error = ifmedia_ioctl(ifp, ifr, &Adapter->media, command);
+      error = ifmedia_ioctl(ifp, ifr, &adapter->media, command);
+      break;
+   case SIOCSIFCAP:
+      IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)");
+      mask = ifr->ifr_reqcap ^ ifp->if_capenable;
+      if (mask & IFCAP_HWCSUM) {
+         if (IFCAP_HWCSUM & ifp->if_capenable)
+            ifp->if_capenable &= ~IFCAP_HWCSUM;
+         else
+            ifp->if_capenable |= IFCAP_HWCSUM;
+         if (ifp->if_flags & IFF_RUNNING)
+            em_init(adapter);
+      }
       break;
    default:
       IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%d)\n", (int)command);
@@ -625,37 +632,37 @@ em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data)
 }
 
 static void
-em_set_promisc(struct adapter * Adapter)
+em_set_promisc(struct adapter * adapter)
 {
 
    u_int32_t       reg_rctl;
-   struct ifnet   *ifp = &Adapter->interface_data.ac_if;
+   struct ifnet   *ifp = &adapter->interface_data.ac_if;
 
-   reg_rctl = E1000_READ_REG(&Adapter->shared, RCTL);
+   reg_rctl = E1000_READ_REG(&adapter->shared, RCTL);
 
    if(ifp->if_flags & IFF_PROMISC) {
       reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
-      E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl);
+      E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl);
    }
    else if (ifp->if_flags & IFF_ALLMULTI) {
       reg_rctl |= E1000_RCTL_MPE;
       reg_rctl &= ~E1000_RCTL_UPE;
-      E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl);
+      E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl);
    }
 
    return;
 }
 
 static void
-em_disable_promisc(struct adapter * Adapter)
+em_disable_promisc(struct adapter * adapter)
 {
    u_int32_t       reg_rctl;
 
-   reg_rctl = E1000_READ_REG(&Adapter->shared, RCTL);
+   reg_rctl = E1000_READ_REG(&adapter->shared, RCTL);
 
    reg_rctl &=  (~E1000_RCTL_UPE);
    reg_rctl &=  (~E1000_RCTL_MPE);
-   E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl);
+   E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl);
 
    return;
 }
@@ -669,25 +676,25 @@ em_disable_promisc(struct adapter * Adapter)
  **********************************************************************/
 
 static void
-em_set_multi(struct adapter * Adapter)
+em_set_multi(struct adapter * adapter)
 {
    u_int32_t reg_rctl = 0;
    u_int8_t  mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS];
-   u_int16_t PciCommandWord;
+   u_int16_t pci_cmd_word;
    struct ifmultiaddr  *ifma;
    int mcnt = 0;
-   struct ifnet   *ifp = &Adapter->interface_data.ac_if;
+   struct ifnet   *ifp = &adapter->interface_data.ac_if;
 
    IOCTL_DEBUGOUT("em_set_multi: begin");
    
-    if(Adapter->shared.mac_type == em_82542_rev2_0) {
-       reg_rctl = E1000_READ_REG(&Adapter->shared, RCTL);
-       if(Adapter->shared.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
-          PciCommandWord = Adapter->shared.pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE;
-          pci_write_config(Adapter->dev, PCIR_COMMAND, PciCommandWord, 2);
+    if(adapter->shared.mac_type == em_82542_rev2_0) {
+       reg_rctl = E1000_READ_REG(&adapter->shared, RCTL);
+       if(adapter->shared.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
+          pci_cmd_word = adapter->shared.pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE;
+          pci_write_config(adapter->dev, PCIR_COMMAND, pci_cmd_word, 2);
        }
        reg_rctl |= E1000_RCTL_RST;
-       E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl);
+       E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl);
        msec_delay(5);
     }
 
@@ -705,20 +712,20 @@ em_set_multi(struct adapter * Adapter)
     }
 
     if (mcnt > MAX_NUM_MULTICAST_ADDRESSES) {
-       reg_rctl = E1000_READ_REG(&Adapter->shared, RCTL);
+       reg_rctl = E1000_READ_REG(&adapter->shared, RCTL);
        reg_rctl |= E1000_RCTL_MPE;
-       E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl);
+       E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl);
     }
     else
-       em_mc_addr_list_update(&Adapter->shared, mta, mcnt, 0);
+       em_mc_addr_list_update(&adapter->shared, mta, mcnt, 0);
 
-    if(Adapter->shared.mac_type == em_82542_rev2_0) {
-       reg_rctl = E1000_READ_REG(&Adapter->shared, RCTL);
+    if(adapter->shared.mac_type == em_82542_rev2_0) {
+       reg_rctl = E1000_READ_REG(&adapter->shared, RCTL);
        reg_rctl &= ~E1000_RCTL_RST;
-       E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl);
+       E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl);
        msec_delay(5);
-       if(Adapter->shared.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
-          pci_write_config(Adapter->dev, PCIR_COMMAND, Adapter->shared.pci_cmd_word, 2);
+       if(adapter->shared.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
+          pci_write_config(adapter->dev, PCIR_COMMAND, adapter->shared.pci_cmd_word, 2);
        }
     }
 
@@ -735,23 +742,23 @@ em_set_multi(struct adapter * Adapter)
 static void
 em_watchdog(struct ifnet *ifp)
 {
-   struct adapter * Adapter;
-   Adapter = ifp->if_softc;
+   struct adapter * adapter;
+   adapter = ifp->if_softc;
  
    /* If we are in this routine because of pause frames, then
     * don't reset the hardware.
     */
-   if(E1000_READ_REG(&Adapter->shared, STATUS) & E1000_STATUS_TXOFF) {
+   if(E1000_READ_REG(&adapter->shared, STATUS) & E1000_STATUS_TXOFF) {
       ifp->if_timer = EM_TX_TIMEOUT;
       return;
    }
 
-   printf("em%d: watchdog timeout -- resetting\n", Adapter->unit);
+   printf("em%d: watchdog timeout -- resetting\n", adapter->unit);
 
    ifp->if_flags &= ~IFF_RUNNING;
 
-   em_stop(Adapter);
-   em_init(Adapter);
+   em_stop(adapter);
+   em_init(adapter);
 
    ifp->if_oerrors++;
    return;
@@ -769,42 +776,42 @@ em_local_timer(void *arg)
 {
    int s;
    struct ifnet   *ifp;
-   struct adapter * Adapter = arg;
-   ifp = &Adapter->interface_data.ac_if;
+   struct adapter * adapter = arg;
+   ifp = &adapter->interface_data.ac_if;
 
    s = splimp();
 
-   em_check_for_link(&Adapter->shared);
-   em_print_link_status(Adapter);
-   em_update_stats_counters(Adapter);   
+   em_check_for_link(&adapter->shared);
+   em_print_link_status(adapter);
+   em_update_stats_counters(adapter);   
    if(em_display_debug_stats && ifp->if_flags & IFF_RUNNING) {
-      em_print_hw_stats(Adapter);
+      em_print_hw_stats(adapter);
    }
-   Adapter->timer_handle = timeout(em_local_timer, Adapter, 2*hz);
+   adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz);
 
    splx(s);
    return;
 }
 
 static void
-em_print_link_status(struct adapter * Adapter)
+em_print_link_status(struct adapter * adapter)
 {
-   if(E1000_READ_REG(&Adapter->shared, STATUS) & E1000_STATUS_LU) {
-      if(Adapter->LinkIsActive == 0) {
-         em_get_speed_and_duplex(&Adapter->shared, &Adapter->LineSpeed, &Adapter->FullDuplex);
+   if(E1000_READ_REG(&adapter->shared, STATUS) & E1000_STATUS_LU) {
+      if(adapter->link_active == 0) {
+         em_get_speed_and_duplex(&adapter->shared, &adapter->link_speed, &adapter->link_duplex);
          printf("em%d: Link is up %d Mbps %s\n",
-                Adapter->unit,
-                Adapter->LineSpeed,
-                ((Adapter->FullDuplex == FULL_DUPLEX) ?
+                adapter->unit,
+                adapter->link_speed,
+                ((adapter->link_duplex == FULL_DUPLEX) ?
                  "Full Duplex" : "Half Duplex"));
-         Adapter->LinkIsActive = 1;
+         adapter->link_active = 1;
       }
    } else {
-      if(Adapter->LinkIsActive == 1) {
-         Adapter->LineSpeed = 0;
-         Adapter->FullDuplex = 0;
-         printf("em%d: Link is Down\n", Adapter->unit);
-         Adapter->LinkIsActive = 0;
+      if(adapter->link_active == 1) {
+         adapter->link_speed = 0;
+         adapter->link_duplex = 0;
+         printf("em%d: Link is Down\n", adapter->unit);
+         adapter->link_active = 0;
       }
    }
 
@@ -827,53 +834,55 @@ em_init(void *arg)
 {
    int             s;
    struct ifnet   *ifp;
-   struct adapter * Adapter = arg;
+   struct adapter * adapter = arg;
 
    INIT_DEBUGOUT("em_init: begin");
 
    s = splimp();
 
-   em_stop(Adapter);
+   em_stop(adapter);
 
    /* Initialize the hardware */
-   if (em_hardware_init(Adapter)) {
-      printf("em%d: Unable to initialize the hardware\n", Adapter->unit);
+   if (em_hardware_init(adapter)) {
+      printf("em%d: Unable to initialize the hardware\n", adapter->unit);
       splx(s);
       return;
    }
-   Adapter->shared.adapter_stopped = FALSE;
+   adapter->shared.adapter_stopped = FALSE;
    
    /* Prepare transmit descriptors and buffers */
-   if (em_setup_transmit_structures(Adapter)) {
-      printf("em%d: Could not setup transmit structures\n", Adapter->unit);
-      em_stop(Adapter); 
+   if (em_setup_transmit_structures(adapter)) {
+      printf("em%d: Could not setup transmit structures\n", adapter->unit);
+      em_stop(adapter); 
       splx(s);
       return;
    }
-   em_initialize_transmit_unit(Adapter);
+   em_initialize_transmit_unit(adapter);
 
    /* Setup Multicast table */
-   em_set_multi(Adapter);
+   em_set_multi(adapter);
 
    /* Prepare receive descriptors and buffers */
-   if (em_setup_receive_structures(Adapter)) {
-      printf("em%d: Could not setup receive structures\n", Adapter->unit);
-      em_stop(Adapter);
+   if (em_setup_receive_structures(adapter)) {
+      printf("em%d: Could not setup receive structures\n", adapter->unit);
+      em_stop(adapter);
       splx(s);
       return;
    }
-   em_initialize_receive_unit(Adapter);
+   em_initialize_receive_unit(adapter);
 
-   ifp = &Adapter->interface_data.ac_if;
+   ifp = &adapter->interface_data.ac_if;
    ifp->if_flags |= IFF_RUNNING;
    ifp->if_flags &= ~IFF_OACTIVE;
 
-   if(Adapter->shared.mac_type >= em_82543)
-      ifp->if_hwassist = EM_CHECKSUM_FEATURES;
+   if(adapter->shared.mac_type >= em_82543) {
+      if (ifp->if_capenable & IFCAP_TXCSUM)
+         ifp->if_hwassist = EM_CHECKSUM_FEATURES;
+   }
 
-   Adapter->timer_handle = timeout(em_local_timer, Adapter, 2*hz);
-   em_clear_hw_cntrs(&Adapter->shared);
-   EnableInterrupts(Adapter);
+   adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz);
+   em_clear_hw_cntrs(&adapter->shared);
+   em_enable_intr(adapter);
 
    splx(s);
    return;
@@ -891,15 +900,15 @@ static void
 em_stop(void *arg)
 {
    struct ifnet   *ifp;
-   struct adapter * Adapter = arg;
-   ifp = &Adapter->interface_data.ac_if;
+   struct adapter * adapter = arg;
+   ifp = &adapter->interface_data.ac_if;
 
    INIT_DEBUGOUT("em_stop: begin\n");
-   DisableInterrupts(Adapter);
-   em_adapter_stop(&Adapter->shared);
-   untimeout(em_local_timer, Adapter, Adapter->timer_handle);
-   em_free_transmit_structures(Adapter);
-   em_free_receive_structures(Adapter);
+   em_disable_intr(adapter);
+   em_adapter_stop(&adapter->shared);
+   untimeout(em_local_timer, adapter, adapter->timer_handle);
+   em_free_transmit_structures(adapter);
+   em_free_receive_structures(adapter);
 
 
    /* Tell the stack that the interface is no longer active */
@@ -917,33 +926,33 @@ em_stop(void *arg)
 static void
 em_intr(void *arg)
 {
-   u_int32_t            ProcessCount = EM_MAX_INTR;
-   u_int32_t            IcrContents;
-   struct ifnet   *ifp;
-   struct adapter *Adapter = arg;
+   u_int32_t       loop_cnt = EM_MAX_INTR;
+   u_int32_t       reg_icr;
+   struct ifnet    *ifp;
+   struct adapter  *adapter = arg;
 
-   ifp = &Adapter->interface_data.ac_if;
+   ifp = &adapter->interface_data.ac_if;
 
-   DisableInterrupts(Adapter);
-   while(ProcessCount > 0 && (IcrContents = E1000_READ_REG(&Adapter->shared, ICR)) != 0) {
+   em_disable_intr(adapter);
+   while(loop_cnt > 0 && (reg_icr = E1000_READ_REG(&adapter->shared, ICR)) != 0) {
 
       /* Link status change */
-      if(IcrContents & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
-         untimeout(em_local_timer, Adapter, Adapter->timer_handle);
-         Adapter->shared.get_link_status = 1;
-         em_check_for_link(&Adapter->shared);
-         em_print_link_status(Adapter);
-         Adapter->timer_handle = timeout(em_local_timer, Adapter, 2*hz);      
+      if(reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
+         untimeout(em_local_timer, adapter, adapter->timer_handle);
+         adapter->shared.get_link_status = 1;
+         em_check_for_link(&adapter->shared);
+         em_print_link_status(adapter);
+         adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz);      
       }
 
       if (ifp->if_flags & IFF_RUNNING) {
-         em_process_receive_interrupts(Adapter);
-         em_clean_transmit_interrupts(Adapter);
+         em_process_receive_interrupts(adapter);
+         em_clean_transmit_interrupts(adapter);
       }
-      ProcessCount--;
+      loop_cnt--;
    }
 
-   EnableInterrupts(Adapter);
+   em_enable_intr(adapter);
 
    if(ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL)
       em_start(ifp);
@@ -963,37 +972,37 @@ em_intr(void *arg)
 static void
 em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
 {
-   struct adapter * Adapter = ifp->if_softc;
+   struct adapter * adapter = ifp->if_softc;
 
    INIT_DEBUGOUT("em_media_status: begin");
 
-   em_check_for_link(&Adapter->shared);
-   if(E1000_READ_REG(&Adapter->shared, STATUS) & E1000_STATUS_LU) {
-      if(Adapter->LinkIsActive == 0) {
-         em_get_speed_and_duplex(&Adapter->shared, &Adapter->LineSpeed, &Adapter->FullDuplex);
-         Adapter->LinkIsActive = 1;
+   em_check_for_link(&adapter->shared);
+   if(E1000_READ_REG(&adapter->shared, STATUS) & E1000_STATUS_LU) {
+      if(adapter->link_active == 0) {
+         em_get_speed_and_duplex(&adapter->shared, &adapter->link_speed, &adapter->link_duplex);
+         adapter->link_active = 1;
       }
    }
    else {
-      if(Adapter->LinkIsActive == 1) {
-         Adapter->LineSpeed = 0;
-         Adapter->FullDuplex = 0;
-         Adapter->LinkIsActive = 0;
+      if(adapter->link_active == 1) {
+         adapter->link_speed = 0;
+         adapter->link_duplex = 0;
+         adapter->link_active = 0;
       }
    }
 
    ifmr->ifm_status = IFM_AVALID;
    ifmr->ifm_active = IFM_ETHER;
 
-   if (!Adapter->LinkIsActive)
+   if (!adapter->link_active)
       return;
 
    ifmr->ifm_status |= IFM_ACTIVE;
 
-   if (Adapter->shared.media_type == em_media_type_fiber) {
+   if (adapter->shared.media_type == em_media_type_fiber) {
       ifmr->ifm_active |= IFM_1000_SX | IFM_FDX;
    } else {
-      switch (Adapter->LineSpeed) {
+      switch (adapter->link_speed) {
       case 10:
          ifmr->ifm_active |= IFM_10_T;
          break;
@@ -1004,7 +1013,7 @@ em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
          ifmr->ifm_active |= IFM_1000_TX;
          break;
       }
-      if (Adapter->FullDuplex == FULL_DUPLEX)
+      if (adapter->link_duplex == FULL_DUPLEX)
          ifmr->ifm_active |= IFM_FDX;
       else
          ifmr->ifm_active |= IFM_HDX;
@@ -1023,8 +1032,8 @@ em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
 static int
 em_media_change(struct ifnet *ifp)
 {
-   struct adapter * Adapter = ifp->if_softc;
-   struct ifmedia  *ifm = &Adapter->media;
+   struct adapter * adapter = ifp->if_softc;
+   struct ifmedia  *ifm = &adapter->media;
    
    INIT_DEBUGOUT("em_media_change: begin");
 
@@ -1033,39 +1042,39 @@ em_media_change(struct ifnet *ifp)
 
    switch(IFM_SUBTYPE(ifm->ifm_media)) {
    case IFM_AUTO:
-      if (Adapter->shared.autoneg)
+      if (adapter->shared.autoneg)
          return 0;
       else {
-         Adapter->shared.autoneg = DO_AUTO_NEG;
-         Adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT;
+         adapter->shared.autoneg = DO_AUTO_NEG;
+         adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT;
       }
       break;
    case IFM_1000_SX:
    case IFM_1000_TX:
-      Adapter->shared.autoneg = DO_AUTO_NEG;
-      Adapter->shared.autoneg_advertised = ADVERTISE_1000_FULL;
+      adapter->shared.autoneg = DO_AUTO_NEG;
+      adapter->shared.autoneg_advertised = ADVERTISE_1000_FULL;
       break;
    case IFM_100_TX:
-      Adapter->shared.autoneg = FALSE;
-      Adapter->shared.autoneg_advertised = 0;
+      adapter->shared.autoneg = FALSE;
+      adapter->shared.autoneg_advertised = 0;
       if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
-         Adapter->shared.forced_speed_duplex = em_100_full;
+         adapter->shared.forced_speed_duplex = em_100_full;
       else
-         Adapter->shared.forced_speed_duplex = em_100_half;
+         adapter->shared.forced_speed_duplex = em_100_half;
       break;
    case IFM_10_T:
-     Adapter->shared.autoneg = FALSE;
-     Adapter->shared.autoneg_advertised = 0;
+     adapter->shared.autoneg = FALSE;
+     adapter->shared.autoneg_advertised = 0;
      if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
-        Adapter->shared.forced_speed_duplex = em_10_full;
+        adapter->shared.forced_speed_duplex = em_10_full;
      else
-        Adapter->shared.forced_speed_duplex = em_10_half;
+        adapter->shared.forced_speed_duplex = em_10_half;
      break;
    default:
-      printf("em%d: Unsupported media type\n", Adapter->unit);
+      printf("em%d: Unsupported media type\n", adapter->unit);
    }
 
-   em_init(Adapter);
+   em_init(adapter);
 
    return(0);
 }
@@ -1078,99 +1087,100 @@ em_media_change(struct ifnet *ifp)
  *
  **********************************************************************/
 static void
-em_identify_hardware(struct adapter * Adapter)
+em_identify_hardware(struct adapter * adapter)
 {
-   device_t dev = Adapter->dev;
+   device_t dev = adapter->dev;
 
    /* Make sure our PCI config space has the necessary stuff set */
-   Adapter->shared.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2);
-   if (!((Adapter->shared.pci_cmd_word & PCIM_CMD_BUSMASTEREN) &&
-         (Adapter->shared.pci_cmd_word & PCIM_CMD_MEMEN))) {
+   adapter->shared.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2);
+   if (!((adapter->shared.pci_cmd_word & PCIM_CMD_BUSMASTEREN) &&
+         (adapter->shared.pci_cmd_word & PCIM_CMD_MEMEN))) {
       printf("em%d: Memory Access and/or Bus Master bits were not set!\n", 
-             Adapter->unit);
-      Adapter->shared.pci_cmd_word |= (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN);
-      pci_write_config(dev, PCIR_COMMAND, Adapter->shared.pci_cmd_word, 2);
+             adapter->unit);
+      adapter->shared.pci_cmd_word |= (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN);
+      pci_write_config(dev, PCIR_COMMAND, adapter->shared.pci_cmd_word, 2);
    }
 
    /* Save off the information about this board */
-   Adapter->VendorId = pci_get_vendor(dev);
-   Adapter->DeviceId = pci_get_device(dev);
-   Adapter->RevId = pci_read_config(dev, PCIR_REVID, 1);
-   Adapter->SubVendorId = pci_read_config(dev, PCIR_SUBVEND_0, 2);
-   Adapter->SubSystemId = pci_read_config(dev, PCIR_SUBDEV_0, 2);
+   adapter->shared.vendor_id = pci_get_vendor(dev);
+   adapter->shared.device_id = pci_get_device(dev);
+   adapter->shared.revision_id = pci_read_config(dev, PCIR_REVID, 1);
+   adapter->shared.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2);
+   adapter->shared.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2);
 
-   INIT_DEBUGOUT2("device id = 0x%x, Revid = 0x%x", Adapter->DeviceId, Adapter->RevId);
    
    /* Set MacType, etc. based on this PCI info */
-   switch (Adapter->DeviceId) {
-   case PCI_DEVICE_ID_82542:
-      Adapter->shared.mac_type = (Adapter->RevId == 3) ?
+   switch (adapter->shared.device_id) {
+   case E1000_DEV_ID_82542:
+      adapter->shared.mac_type = (adapter->shared.revision_id == 3) ?
          em_82542_rev2_1 : em_82542_rev2_0;
       break;
-   case PCI_DEVICE_ID_82543GC_FIBER:
-   case PCI_DEVICE_ID_82543GC_COPPER:
-      Adapter->shared.mac_type = em_82543;
+   case E1000_DEV_ID_82543GC_FIBER:
+   case E1000_DEV_ID_82543GC_COPPER:
+      adapter->shared.mac_type = em_82543;
       break;
-   case PCI_DEVICE_ID_82544EI_FIBER:
-   case PCI_DEVICE_ID_82544EI_COPPER:
-   case PCI_DEVICE_ID_82544GC_COPPER:
-   case PCI_DEVICE_ID_82544GC_STRG:
-      Adapter->shared.mac_type = em_82544;
+   case E1000_DEV_ID_82544EI_FIBER:
+   case E1000_DEV_ID_82544EI_COPPER:
+   case E1000_DEV_ID_82544GC_COPPER:
+   case E1000_DEV_ID_82544GC_LOM:
+      adapter->shared.mac_type = em_82544;
       break;
+   case E1000_DEV_ID_82540EM:
+      adapter->shared.mac_type = em_82540;
    default:
-      INIT_DEBUGOUT1("Unknown device id 0x%x", Adapter->DeviceId);
+      INIT_DEBUGOUT1("Unknown device id 0x%x", adapter->shared.device_id);
    }
    return;
 }
 
 static int
-em_allocate_pci_resources(struct adapter * Adapter)
+em_allocate_pci_resources(struct adapter * adapter)
 {
    int             resource_id = EM_MMBA;
-   device_t        dev = Adapter->dev;
+   device_t        dev = adapter->dev;
 
-   Adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY,
+   adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY,
                                             &resource_id, 0, ~0, 1,
                                             RF_ACTIVE);
-   if (!(Adapter->res_memory)) {
-      printf("em%d: Unable to allocate bus resource: memory\n", Adapter->unit);
+   if (!(adapter->res_memory)) {
+      printf("em%d: Unable to allocate bus resource: memory\n", adapter->unit);
       return(ENXIO);
    }
-   Adapter->osdep.bus_space_tag = rman_get_bustag(Adapter->res_memory);
-   Adapter->osdep.bus_space_handle = rman_get_bushandle(Adapter->res_memory);
-   Adapter->shared.hw_addr = (uint8_t *)Adapter->osdep.bus_space_handle;
+   adapter->osdep.bus_space_tag = rman_get_bustag(adapter->res_memory);
+   adapter->osdep.bus_space_handle = rman_get_bushandle(adapter->res_memory);
+   adapter->shared.hw_addr = (uint8_t *)adapter->osdep.bus_space_handle;
 
    resource_id = 0x0;
-   Adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ,
+   adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ,
                                                &resource_id, 0, ~0, 1,
                                                RF_SHAREABLE | RF_ACTIVE);
-   if (!(Adapter->res_interrupt)) {
-      printf("em%d: Unable to allocate bus resource: interrupt\n", Adapter->unit);
+   if (!(adapter->res_interrupt)) {
+      printf("em%d: Unable to allocate bus resource: interrupt\n", adapter->unit);
       return(ENXIO);
    }
-   if (bus_setup_intr(dev, Adapter->res_interrupt, INTR_TYPE_NET,
-                  (void (*)(void *)) em_intr, Adapter,
-                  &Adapter->int_handler_tag)) {
-      printf("em%d: Error registering interrupt handler!\n", Adapter->unit);
+   if (bus_setup_intr(dev, adapter->res_interrupt, INTR_TYPE_NET,
+                  (void (*)(void *)) em_intr, adapter,
+                  &adapter->int_handler_tag)) {
+      printf("em%d: Error registering interrupt handler!\n", adapter->unit);
       return(ENXIO);
    }
 
-   Adapter->shared.back = &Adapter->osdep;
+   adapter->shared.back = &adapter->osdep;
 
    return(0);
 }
 
 static void
-em_free_pci_resources(struct adapter * Adapter)
+em_free_pci_resources(struct adapter * adapter)
 {
-   device_t dev = Adapter->dev;
+   device_t dev = adapter->dev;
 
-   if(Adapter->res_interrupt != NULL) {
-      bus_teardown_intr(dev, Adapter->res_interrupt, Adapter->int_handler_tag);
-      bus_release_resource(dev, SYS_RES_IRQ, 0, Adapter->res_interrupt);
+   if(adapter->res_interrupt != NULL) {
+      bus_teardown_intr(dev, adapter->res_interrupt, adapter->int_handler_tag);
+      bus_release_resource(dev, SYS_RES_IRQ, 0, adapter->res_interrupt);
    }
-   if (Adapter->res_memory != NULL) {
-      bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA, Adapter->res_memory);
+   if (adapter->res_memory != NULL) {
+      bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA, adapter->res_memory);
    }
    return;
 }
@@ -1178,60 +1188,60 @@ em_free_pci_resources(struct adapter * Adapter)
 /*********************************************************************
  *
  *  Initialize the hardware to a configuration as specified by the
- *  Adapter structure. The controller is reset, the EEPROM is
+ *  adapter structure. The controller is reset, the EEPROM is
  *  verified, the MAC address is set, then the shared initialization
  *  routines are called.
  *
  **********************************************************************/
 static int
-em_hardware_init(struct adapter * Adapter)
+em_hardware_init(struct adapter * adapter)
 {
    /* Issue a global reset */
-   Adapter->shared.adapter_stopped = FALSE;
-   em_adapter_stop(&Adapter->shared);
-   Adapter->shared.adapter_stopped = FALSE;
+   adapter->shared.adapter_stopped = FALSE;
+   em_adapter_stop(&adapter->shared);
+   adapter->shared.adapter_stopped = FALSE;
 
    /* Make sure we have a good EEPROM before we read from it */
-   if (!em_validate_eeprom_checksum(&Adapter->shared)) {
-      printf("em%d: The EEPROM Checksum Is Not Valid\n", Adapter->unit);
+   if (!em_validate_eeprom_checksum(&adapter->shared)) {
+      printf("em%d: The EEPROM Checksum Is Not Valid\n", adapter->unit);
       return EIO;
    }
    /* Copy the permanent MAC address and part number out of the EEPROM */
-   em_read_mac_address(Adapter, Adapter->interface_data.ac_enaddr);
-   memcpy(Adapter->shared.mac_addr, Adapter->interface_data.ac_enaddr,
+   em_read_mac_address(adapter, adapter->interface_data.ac_enaddr);
+   memcpy(adapter->shared.mac_addr, adapter->interface_data.ac_enaddr,
          ETH_LENGTH_OF_ADDRESS);
-   em_read_part_num(&Adapter->shared, &(Adapter->PartNumber));
+   em_read_part_num(&adapter->shared, &(adapter->part_num));
 
-   if (!em_init_hw(&Adapter->shared)) {
-      printf("em%d: Hardware Initialization Failed", Adapter->unit);
+   if (!em_init_hw(&adapter->shared)) {
+      printf("em%d: Hardware Initialization Failed", adapter->unit);
       return EIO;
    }
 
-   em_check_for_link(&Adapter->shared);
-   if (E1000_READ_REG(&Adapter->shared, STATUS) & E1000_STATUS_LU)
-      Adapter->LinkIsActive = 1;
+   em_check_for_link(&adapter->shared);
+   if (E1000_READ_REG(&adapter->shared, STATUS) & E1000_STATUS_LU)
+      adapter->link_active = 1;
    else
-      Adapter->LinkIsActive = 0;
+      adapter->link_active = 0;
  
-   if (Adapter->LinkIsActive) {
-      em_get_speed_and_duplex(&Adapter->shared, &Adapter->LineSpeed, &Adapter->FullDuplex);
+   if (adapter->link_active) {
+      em_get_speed_and_duplex(&adapter->shared, &adapter->link_speed, &adapter->link_duplex);
    } else {
-      Adapter->LineSpeed = 0;
-      Adapter->FullDuplex = 0;
+      adapter->link_speed = 0;
+      adapter->link_duplex = 0;
    }
 
    return 0;
 }
 
 static void
-em_read_mac_address(struct adapter * Adapter, u_int8_t * NodeAddress)
+em_read_mac_address(struct adapter * adapter, u_int8_t * NodeAddress)
 {
    u_int16_t       EepromWordValue;
    int             i;
 
    for (i = 0; i < NODE_ADDRESS_SIZE; i += 2) {
       EepromWordValue =
-         em_read_eeprom(&Adapter->shared, EEPROM_NODE_ADDRESS_BYTE_0 + (i / 2));
+         em_read_eeprom(&adapter->shared, EEPROM_NODE_ADDRESS_BYTE_0 + (i / 2));
       NodeAddress[i] = (uint8_t) (EepromWordValue & 0x00FF);
       NodeAddress[i + 1] = (uint8_t) (EepromWordValue >> 8);
    }
@@ -1245,51 +1255,55 @@ em_read_mac_address(struct adapter * Adapter, u_int8_t * NodeAddress)
  *
  **********************************************************************/
 static void
-em_setup_interface(device_t dev, struct adapter * Adapter)
+em_setup_interface(device_t dev, struct adapter * adapter)
 {
    struct ifnet   *ifp;
    INIT_DEBUGOUT("em_setup_interface: begin");
 
-   ifp = &Adapter->interface_data.ac_if;
-   ifp->if_unit = Adapter->unit;
+   ifp = &adapter->interface_data.ac_if;
+   ifp->if_unit = adapter->unit;
    ifp->if_name = "em";
    ifp->if_mtu = ETHERMTU;
    ifp->if_output = ether_output;
    ifp->if_baudrate = 1000000000;
    ifp->if_init =  em_init;
-   ifp->if_softc = Adapter;
+   ifp->if_softc = adapter;
    ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
    ifp->if_ioctl = em_ioctl;
    ifp->if_start = em_start;
    ifp->if_watchdog = em_watchdog;
-   ifp->if_snd.ifq_maxlen = Adapter->NumTxDescriptors - 1;
+   ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1;
    ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
 
+   if (adapter->shared.mac_type >= em_82543) {
+      ifp->if_capabilities = IFCAP_HWCSUM;
+      ifp->if_capenable = ifp->if_capabilities;
+   }
+
    /* 
     * 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,
+   ifmedia_init(&adapter->media, IFM_IMASK, em_media_change,
                 em_media_status);
-   if (Adapter->shared.media_type == em_media_type_fiber) {
-      ifmedia_add(&Adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 0,
+   if (adapter->shared.media_type == em_media_type_fiber) {
+      ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 0,
                   NULL);
-      ifmedia_add(&Adapter->media, IFM_ETHER | IFM_1000_SX , 0, NULL);
+      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, 0,
+      ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL);
+      ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, 0,
                   NULL);
-      ifmedia_add(&Adapter->media, IFM_ETHER | IFM_100_TX, 0, NULL);
-      ifmedia_add(&Adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 0,
+      ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 0, NULL);
+      ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 0,
                   NULL);
-      ifmedia_add(&Adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 0,
+      ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 0,
                   NULL);
-      ifmedia_add(&Adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL);
+      ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL);
    }
-   ifmedia_add(&Adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL);
-   ifmedia_set(&Adapter->media, IFM_ETHER | IFM_AUTO);
+   ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL);
+   ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO);
 
-   INIT_DEBUGOUT("em_setup_interface: end");
    return;
 }
 
@@ -1301,18 +1315,18 @@ em_setup_interface(device_t dev, struct adapter * Adapter)
  *
  **********************************************************************/
 static int
-em_allocate_transmit_structures(struct adapter * Adapter)
+em_allocate_transmit_structures(struct adapter * adapter)
 {
-   if (!(Adapter->tx_buffer_area =
+   if (!(adapter->tx_buffer_area =
          (struct em_tx_buffer *) malloc(sizeof(struct em_tx_buffer) *
-                                        Adapter->NumTxDescriptors, M_DEVBUF,
+                                        adapter->num_tx_desc, M_DEVBUF,
                                         M_NOWAIT))) {
-      printf("em%d: Unable to allocate tx_buffer memory\n", Adapter->unit);
+      printf("em%d: Unable to allocate tx_buffer memory\n", adapter->unit);
       return ENOMEM;
    }
 
-   bzero(Adapter->tx_buffer_area,
-         sizeof(struct em_tx_buffer) * Adapter->NumTxDescriptors);
+   bzero(adapter->tx_buffer_area,
+         sizeof(struct em_tx_buffer) * adapter->num_tx_desc);
 
    return 0;
 }
@@ -1323,42 +1337,42 @@ em_allocate_transmit_structures(struct adapter * Adapter)
  *
  **********************************************************************/
 static int
-em_setup_transmit_structures(struct adapter * Adapter)
+em_setup_transmit_structures(struct adapter * adapter)
 {
    struct em_tx_buffer   *tx_buffer;
    int             i;
 
-   if (em_allocate_transmit_structures(Adapter))
+   if (em_allocate_transmit_structures(adapter))
       return ENOMEM;
 
-   Adapter->FirstTxDescriptor = Adapter->TxDescBase;
-   Adapter->LastTxDescriptor =
-      Adapter->FirstTxDescriptor + (Adapter->NumTxDescriptors - 1);
+   adapter->first_tx_desc = adapter->tx_desc_base;
+   adapter->last_tx_desc =
+      adapter->first_tx_desc + (adapter->num_tx_desc - 1);
 
    
-   STAILQ_INIT(&Adapter->FreeSwTxPacketList);
-   STAILQ_INIT(&Adapter->UsedSwTxPacketList);
+   STAILQ_INIT(&adapter->free_tx_buffer_list);
+   STAILQ_INIT(&adapter->used_tx_buffer_list);
 
-   tx_buffer = Adapter->tx_buffer_area;
+   tx_buffer = adapter->tx_buffer_area;
 
    /* Setup the linked list of the tx_buffer's */
-   for (i = 0; i < Adapter->NumTxDescriptors; i++, tx_buffer++) {
+   for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) {
       bzero((void *) tx_buffer, sizeof(struct em_tx_buffer));
-      STAILQ_INSERT_TAIL(&Adapter->FreeSwTxPacketList, tx_buffer, em_tx_entry);
+      STAILQ_INSERT_TAIL(&adapter->free_tx_buffer_list, tx_buffer, em_tx_entry);
    }
 
-   bzero((void *) Adapter->FirstTxDescriptor,
-        (sizeof(struct em_tx_desc)) * Adapter->NumTxDescriptors);
+   bzero((void *) adapter->first_tx_desc,
+        (sizeof(struct em_tx_desc)) * adapter->num_tx_desc);
 
    /* Setup TX descriptor pointers */
-   Adapter->NextAvailTxDescriptor = Adapter->FirstTxDescriptor;
-   Adapter->OldestUsedTxDescriptor = Adapter->FirstTxDescriptor;
+   adapter->next_avail_tx_desc = adapter->first_tx_desc;
+   adapter->oldest_used_tx_desc = adapter->first_tx_desc;
 
    /* Set number of descriptors available */
-   Adapter->NumTxDescriptorsAvail = Adapter->NumTxDescriptors;
+   adapter->num_tx_desc_avail = adapter->num_tx_desc;
 
    /* Set checksum context */
-   Adapter->ActiveChecksumContext = OFFLOAD_NONE;
+   adapter->active_checksum_context = OFFLOAD_NONE;
 
    return 0;
 }
@@ -1369,31 +1383,32 @@ em_setup_transmit_structures(struct adapter * Adapter)
  *
  **********************************************************************/
 static void
-em_initialize_transmit_unit(struct adapter * Adapter)
+em_initialize_transmit_unit(struct adapter * adapter)
 {
    u_int32_t       reg_tctl;
    u_int32_t       reg_tipg = 0;
 
    /* Setup the Base and Length of the Tx Descriptor Ring */
-   E1000_WRITE_REG(&Adapter->shared, TDBAL, vtophys((vm_offset_t) Adapter->TxDescBase));
-   E1000_WRITE_REG(&Adapter->shared, TDBAH, 0);
-   E1000_WRITE_REG(&Adapter->shared, TDLEN, Adapter->NumTxDescriptors *
+   E1000_WRITE_REG(&adapter->shared, TDBAL, vtophys((vm_offset_t) adapter->tx_desc_base));
+   E1000_WRITE_REG(&adapter->shared, TDBAH, 0);
+   E1000_WRITE_REG(&adapter->shared, TDLEN, adapter->num_tx_desc *
                sizeof(struct em_tx_desc));
 
    /* Setup the HW Tx Head and Tail descriptor pointers */
-   E1000_WRITE_REG(&Adapter->shared, TDH, 0);
-   E1000_WRITE_REG(&Adapter->shared, TDT, 0);
+   E1000_WRITE_REG(&adapter->shared, TDH, 0);
+   E1000_WRITE_REG(&adapter->shared, TDT, 0);
 
 
-   HW_DEBUGOUT2("Base = %x, Length = %x\n", E1000_READ_REG(&Adapter->shared, TDBAL),
-                E1000_READ_REG(&Adapter->shared, TDLEN));
+   HW_DEBUGOUT2("Base = %x, Length = %x\n", E1000_READ_REG(&adapter->shared, TDBAL),
+                E1000_READ_REG(&adapter->shared, TDLEN));
 
    
    /* Set the default values for the Tx Inter Packet Gap timer */
-   switch (Adapter->shared.mac_type) {
+   switch (adapter->shared.mac_type) {
    case em_82543:
    case em_82544:
-      if (Adapter->shared.media_type == em_media_type_fiber)
+   case em_82540:
+      if (adapter->shared.media_type == em_media_type_fiber)
          reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
       else
          reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
@@ -1407,31 +1422,31 @@ em_initialize_transmit_unit(struct adapter * Adapter)
       reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
       break;
    default:
-      printf("em%d: Invalid mac type detected\n", Adapter->unit);
+      printf("em%d: Invalid mac type detected\n", adapter->unit);
    }
-   E1000_WRITE_REG(&Adapter->shared, TIPG, reg_tipg);
-   E1000_WRITE_REG(&Adapter->shared, TIDV, Adapter->TxIntDelay);
+   E1000_WRITE_REG(&adapter->shared, TIPG, reg_tipg);
+   E1000_WRITE_REG(&adapter->shared, TIDV, adapter->tx_int_delay);
 
    /* Program the Transmit Control Register */
    reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN |
       (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
-   if (Adapter->FullDuplex == 1) {
+   if (adapter->link_duplex == 1) {
       reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
    } else {
       reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
    }
-   E1000_WRITE_REG(&Adapter->shared, TCTL, reg_tctl);
+   E1000_WRITE_REG(&adapter->shared, TCTL, reg_tctl);
 
    /* Setup Transmit Descriptor Settings for this adapter */   
-   Adapter->TxdCmd = E1000_TXD_CMD_IFCS;
+   adapter->txd_cmd = E1000_TXD_CMD_IFCS;
 
-   if(Adapter->TxIntDelay > 0)
-      Adapter->TxdCmd |= E1000_TXD_CMD_IDE;
+   if(adapter->tx_int_delay > 0)
+      adapter->txd_cmd |= E1000_TXD_CMD_IDE;
    
-   if(Adapter->shared.report_tx_early == 1)
-      Adapter->TxdCmd |= E1000_TXD_CMD_RS;
+   if(adapter->shared.report_tx_early == 1)
+      adapter->txd_cmd |= E1000_TXD_CMD_RS;
    else
-      Adapter->TxdCmd |= E1000_TXD_CMD_RPS;
+      adapter->txd_cmd |= E1000_TXD_CMD_RPS;
 
    return;
 }
@@ -1442,24 +1457,24 @@ em_initialize_transmit_unit(struct adapter * Adapter)
  *
  **********************************************************************/
 static void
-em_free_transmit_structures(struct adapter * Adapter)
+em_free_transmit_structures(struct adapter * adapter)
 {
    struct em_tx_buffer   *tx_buffer;
    int             i;
 
    INIT_DEBUGOUT("free_transmit_structures: begin");
 
-   if (Adapter->tx_buffer_area != NULL) {
-      tx_buffer = Adapter->tx_buffer_area;
-      for (i = 0; i < Adapter->NumTxDescriptors; i++, tx_buffer++) {
-         if (tx_buffer->Packet != NULL)
-            m_freem(tx_buffer->Packet);
-         tx_buffer->Packet = NULL;
+   if (adapter->tx_buffer_area != NULL) {
+      tx_buffer = adapter->tx_buffer_area;
+      for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) {
+         if (tx_buffer->m_head != NULL)
+            m_freem(tx_buffer->m_head);
+         tx_buffer->m_head = NULL;
       }
    }
-   if (Adapter->tx_buffer_area != NULL) {
-      free(Adapter->tx_buffer_area, M_DEVBUF);
-      Adapter->tx_buffer_area = NULL;
+   if (adapter->tx_buffer_area != NULL) {
+      free(adapter->tx_buffer_area, M_DEVBUF);
+      adapter->tx_buffer_area = NULL;
    }
    return;
 }
@@ -1472,43 +1487,39 @@ em_free_transmit_structures(struct adapter * Adapter)
  *
  **********************************************************************/
 static void
-em_transmit_checksum_setup(struct adapter * Adapter,
+em_transmit_checksum_setup(struct adapter * adapter,
                 struct mbuf *mp,
                 struct em_tx_buffer *tx_buffer,
                 u_int32_t *txd_upper,
                 u_int32_t *txd_lower) 
 {
    struct em_context_desc *TXD;
-   struct em_tx_desc * CurrentTxDescriptor;
+   struct em_tx_desc * current_tx_desc;
      
    if (mp->m_pkthdr.csum_flags) {
 
       if(mp->m_pkthdr.csum_flags & CSUM_TCP) {
-         TXCSUM_DEBUGOUT("Checksum TCP");
          *txd_upper = E1000_TXD_POPTS_TXSM << 8;
          *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
-         if(Adapter->ActiveChecksumContext == OFFLOAD_TCP_IP)
+         if(adapter->active_checksum_context == OFFLOAD_TCP_IP)
             return;
          else 
-            Adapter->ActiveChecksumContext = OFFLOAD_TCP_IP;
+            adapter->active_checksum_context = OFFLOAD_TCP_IP;
 
       } else if(mp->m_pkthdr.csum_flags & CSUM_UDP) {
-         TXCSUM_DEBUGOUT("Checksum UDP");
          *txd_upper = E1000_TXD_POPTS_TXSM << 8;
          *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
-         if(Adapter->ActiveChecksumContext == OFFLOAD_UDP_IP)
+         if(adapter->active_checksum_context == OFFLOAD_UDP_IP)
             return;
          else 
-            Adapter->ActiveChecksumContext = OFFLOAD_UDP_IP;
+            adapter->active_checksum_context = OFFLOAD_UDP_IP;
       } else {
-         TXCSUM_DEBUGOUT("Invalid protocol for checksum calculation\n");
          *txd_upper = 0;
          *txd_lower = 0;
          return;
       }
    }
    else {
-      TXCSUM_DEBUGOUT("No checksum detected\n");
       *txd_upper = 0;
       *txd_lower = 0;
       return;
@@ -1517,8 +1528,8 @@ em_transmit_checksum_setup(struct adapter * Adapter,
    /* If we reach this point, the checksum offload context
     * needs to be reset.
     */
-   CurrentTxDescriptor = Adapter->NextAvailTxDescriptor;
-   TXD = (struct em_context_desc *)CurrentTxDescriptor;
+   current_tx_desc = adapter->next_avail_tx_desc;
+   TXD = (struct em_context_desc *)current_tx_desc;
 
    TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN;
    TXD->lower_setup.ip_fields.ipcso = ETHER_HDR_LEN + offsetof(struct ip, ip_sum);
@@ -1527,10 +1538,10 @@ em_transmit_checksum_setup(struct adapter * Adapter,
    TXD->upper_setup.tcp_fields.tucss = ETHER_HDR_LEN + sizeof(struct ip);
    TXD->upper_setup.tcp_fields.tucse = 0;
 
-   if(Adapter->ActiveChecksumContext == OFFLOAD_TCP_IP) {
+   if(adapter->active_checksum_context == OFFLOAD_TCP_IP) {
       TXD->upper_setup.tcp_fields.tucso = ETHER_HDR_LEN + sizeof(struct ip) + 
          offsetof(struct tcphdr, th_sum);
-   } else if (Adapter->ActiveChecksumContext == OFFLOAD_UDP_IP) {
+   } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) {
       TXD->upper_setup.tcp_fields.tucso = ETHER_HDR_LEN + sizeof(struct ip) + 
          offsetof(struct udphdr, uh_sum);
    }
@@ -1538,14 +1549,14 @@ em_transmit_checksum_setup(struct adapter * Adapter,
    TXD->tcp_seg_setup.data = 0;
    TXD->cmd_and_length = E1000_TXD_CMD_DEXT;
 
-   if (CurrentTxDescriptor == Adapter->LastTxDescriptor)
-      Adapter->NextAvailTxDescriptor = Adapter->FirstTxDescriptor;
+   if (current_tx_desc == adapter->last_tx_desc)
+      adapter->next_avail_tx_desc = adapter->first_tx_desc;
    else
-      Adapter->NextAvailTxDescriptor++;
+      adapter->next_avail_tx_desc++;
 
-   Adapter->NumTxDescriptorsAvail--;
+   adapter->num_tx_desc_avail--;
     
-   tx_buffer->NumTxDescriptorsUsed++;
+   tx_buffer->num_tx_desc_used++;
    return;
 }
 
@@ -1556,26 +1567,24 @@ em_transmit_checksum_setup(struct adapter * Adapter,
  *
  **********************************************************************/
 static int
-em_get_buf(struct em_rx_buffer *rx_buffer, struct adapter *Adapter,
+em_get_buf(struct em_rx_buffer *rx_buffer, struct adapter *adapter,
            struct mbuf *mp)
 {
    struct mbuf    *nmp;
    struct ifnet   *ifp;
 
-   ifp = &Adapter->interface_data.ac_if;
+   ifp = &adapter->interface_data.ac_if;
 
    if (mp == NULL) {
       MGETHDR(nmp, M_DONTWAIT, MT_DATA);
       if (nmp == NULL) {
-         printf("em%d: Mbuf allocation failed\n", Adapter->unit);
-         Adapter->StdMbufFailed++;
+         adapter->mbuf_alloc_failed++;
          return (ENOBUFS);
       }
       MCLGET(nmp, M_DONTWAIT);
       if ((nmp->m_flags & M_EXT) == 0) {
          m_freem(nmp);
-         printf("em%d: Mbuf cluster allocation failed\n", Adapter->unit);
-         Adapter->StdClusterFailed++;
+         adapter->mbuf_cluster_failed++;
          return (ENOBUFS);
       }
       nmp->m_len = nmp->m_pkthdr.len = MCLBYTES;
@@ -1590,9 +1599,8 @@ em_get_buf(struct em_rx_buffer *rx_buffer, struct adapter *Adapter,
       m_adj(nmp, ETHER_ALIGN);
    }
 
-   rx_buffer->Packet = nmp;
-   rx_buffer->LowPhysicalAddress = vtophys(mtod(nmp, vm_offset_t));
-   rx_buffer->HighPhysicalAddress = 0;
+   rx_buffer->m_head = nmp;
+   rx_buffer->buffer_addr = vtophys(mtod(nmp, vm_offset_t));
 
    return (0);
 }
@@ -1606,27 +1614,27 @@ em_get_buf(struct em_rx_buffer *rx_buffer, struct adapter *Adapter,
  *
  **********************************************************************/
 static int
-em_allocate_receive_structures(struct adapter * Adapter)
+em_allocate_receive_structures(struct adapter * adapter)
 {
    int             i;
    struct em_rx_buffer   *rx_buffer;
 
-   if (!(Adapter->rx_buffer_area =
+   if (!(adapter->rx_buffer_area =
         (struct em_rx_buffer *) malloc(sizeof(struct em_rx_buffer) *
-                                       Adapter->NumRxDescriptors, M_DEVBUF,
+                                       adapter->num_rx_desc, M_DEVBUF,
                                        M_NOWAIT))) {
-      printf("em%d: Unable to allocate rx_buffer memory\n", Adapter->unit);
+      printf("em%d: Unable to allocate rx_buffer memory\n", adapter->unit);
       return (ENOMEM);
    }
 
-   bzero(Adapter->rx_buffer_area,
-         sizeof(struct em_rx_buffer) * Adapter->NumRxDescriptors);
+   bzero(adapter->rx_buffer_area,
+         sizeof(struct em_rx_buffer) * adapter->num_rx_desc);
 
-   for (i = 0, rx_buffer = Adapter->rx_buffer_area;
-       i < Adapter->NumRxDescriptors; i++, rx_buffer++) {
+   for (i = 0, rx_buffer = adapter->rx_buffer_area;
+       i < adapter->num_rx_desc; i++, rx_buffer++) {
 
-      if (em_get_buf(rx_buffer, Adapter, NULL) == ENOBUFS) {
-         rx_buffer->Packet = NULL;
+      if (em_get_buf(rx_buffer, adapter, NULL) == ENOBUFS) {
+         rx_buffer->m_head = NULL;
          return (ENOBUFS);
       }
    }
@@ -1640,41 +1648,41 @@ em_allocate_receive_structures(struct adapter * Adapter)
  *  
  **********************************************************************/
 static int
-em_setup_receive_structures(struct adapter * Adapter)
+em_setup_receive_structures(struct adapter * adapter)
 {
    struct em_rx_buffer   *rx_buffer;
-   struct em_rx_desc * RxDescriptorPtr;
+   struct em_rx_desc     *rx_desc;
    int             i;
 
-   if(em_allocate_receive_structures(Adapter))
+   if(em_allocate_receive_structures(adapter))
       return ENOMEM;
 
-   STAILQ_INIT(&Adapter->RxSwPacketList);
+   STAILQ_INIT(&adapter->rx_buffer_list);
 
-   Adapter->FirstRxDescriptor =
-      (struct em_rx_desc *) Adapter->RxDescBase;
-   Adapter->LastRxDescriptor =
-      Adapter->FirstRxDescriptor + (Adapter->NumRxDescriptors - 1);
+   adapter->first_rx_desc =
+      (struct em_rx_desc *) adapter->rx_desc_base;
+   adapter->last_rx_desc =
+      adapter->first_rx_desc + (adapter->num_rx_desc - 1);
 
-   rx_buffer = (struct em_rx_buffer *) Adapter->rx_buffer_area;
+   rx_buffer = (struct em_rx_buffer *) adapter->rx_buffer_area;
 
-   bzero((void *) Adapter->FirstRxDescriptor,
-        (sizeof(struct em_rx_desc)) * Adapter->NumRxDescriptors);
+   bzero((void *) adapter->first_rx_desc,
+        (sizeof(struct em_rx_desc)) * adapter->num_rx_desc);
 
    /* Build a linked list of rx_buffer's */
-   for (i = 0, RxDescriptorPtr = Adapter->FirstRxDescriptor;
-       i < Adapter->NumRxDescriptors;
-       i++, rx_buffer++, RxDescriptorPtr++) {
-      if (rx_buffer->Packet == NULL)
-         printf("em%d: Receive buffer memory not allocated", Adapter->unit);
+   for (i = 0, rx_desc = adapter->first_rx_desc;
+       i < adapter->num_rx_desc;
+       i++, rx_buffer++, rx_desc++) {
+      if (rx_buffer->m_head == NULL)
+         printf("em%d: Receive buffer memory not allocated", adapter->unit);
       else {
-         RxDescriptorPtr->buffer_addr = rx_buffer->LowPhysicalAddress;
-         STAILQ_INSERT_TAIL(&Adapter->RxSwPacketList, rx_buffer, em_rx_entry);
+         rx_desc->buffer_addr = rx_buffer->buffer_addr;
+         STAILQ_INSERT_TAIL(&adapter->rx_buffer_list, rx_buffer, em_rx_entry);
       }
    }
 
    /* Setup our descriptor pointers */
-   Adapter->NextRxDescriptorToCheck = Adapter->FirstRxDescriptor;
+   adapter->next_rx_desc_to_check = adapter->first_rx_desc;
 
    return(0);
 }
@@ -1685,39 +1693,42 @@ em_setup_receive_structures(struct adapter * Adapter)
  *  
  **********************************************************************/
 static void
-em_initialize_receive_unit(struct adapter * Adapter)
+em_initialize_receive_unit(struct adapter * adapter)
 {
    u_int32_t       reg_rctl;
    u_int32_t       reg_rxcsum;
+   struct ifnet    *ifp;
+   
+   ifp = &adapter->interface_data.ac_if;
 
    /* Make sure receives are disabled while setting up the descriptor ring */
-   E1000_WRITE_REG(&Adapter->shared, RCTL, 0);
+   E1000_WRITE_REG(&adapter->shared, RCTL, 0);
 
    /* Set the Receive Delay Timer Register */
-   E1000_WRITE_REG(&Adapter->shared, RDTR, Adapter->RxIntDelay | E1000_RDT_FPDB);
+   E1000_WRITE_REG(&adapter->shared, RDTR, adapter->rx_int_delay | E1000_RDT_FPDB);
 
    /* Setup the Base and Length of the Rx Descriptor Ring */
-   E1000_WRITE_REG(&Adapter->shared, RDBAL, vtophys((vm_offset_t) Adapter->RxDescBase));
-   E1000_WRITE_REG(&Adapter->shared, RDBAH, 0);
-   E1000_WRITE_REG(&Adapter->shared, RDLEN, Adapter->NumRxDescriptors *
+   E1000_WRITE_REG(&adapter->shared, RDBAL, vtophys((vm_offset_t) adapter->rx_desc_base));
+   E1000_WRITE_REG(&adapter->shared, RDBAH, 0);
+   E1000_WRITE_REG(&adapter->shared, RDLEN, adapter->num_rx_desc *
                sizeof(struct em_rx_desc));
 
    /* Setup the HW Rx Head and Tail Descriptor Pointers */
-   E1000_WRITE_REG(&Adapter->shared, RDH, 0);
-   E1000_WRITE_REG(&Adapter->shared, RDT,
-               (((u_int32_t) Adapter->LastRxDescriptor -
-                 (u_int32_t) Adapter->FirstRxDescriptor) >> 4));
+   E1000_WRITE_REG(&adapter->shared, RDH, 0);
+   E1000_WRITE_REG(&adapter->shared, RDT,
+               (((u_int32_t) adapter->last_rx_desc -
+                 (u_int32_t) adapter->first_rx_desc) >> 4));
    
    /* Setup the Receive Control Register */
    reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
       E1000_RCTL_RDMTS_HALF |
-      (Adapter->shared.mc_filter_type << E1000_RCTL_MO_SHIFT);
+      (adapter->shared.mc_filter_type << E1000_RCTL_MO_SHIFT);
 
-   if (Adapter->shared.tbi_compatibility_on == TRUE)
+   if (adapter->shared.tbi_compatibility_on == TRUE)
       reg_rctl |= E1000_RCTL_SBP;
 
 
-   switch (Adapter->RxBufferLen) {
+   switch (adapter->rx_buffer_len) {
    case EM_RXBUFFER_2048:
       reg_rctl |= E1000_RCTL_SZ_2048 | E1000_RCTL_LPE;
       break;
@@ -1735,14 +1746,14 @@ em_initialize_receive_unit(struct adapter * Adapter)
    }
 
    /* Enable 82543 Receive Checksum Offload for TCP and UDP */
-   if((Adapter->shared.mac_type >= em_82543) && (Adapter->RxChecksum == 1)) {
-      reg_rxcsum = E1000_READ_REG(&Adapter->shared, RXCSUM);
+   if((adapter->shared.mac_type >= em_82543) && (ifp->if_capenable & IFCAP_RXCSUM)) {
+      reg_rxcsum = E1000_READ_REG(&adapter->shared, RXCSUM);
       reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL);
-      E1000_WRITE_REG(&Adapter->shared, RXCSUM, reg_rxcsum);
+      E1000_WRITE_REG(&adapter->shared, RXCSUM, reg_rxcsum);
    }
 
    /* Enable Receives */
-   E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl);
+   E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl);
 
    return;
 }
@@ -1753,24 +1764,24 @@ em_initialize_receive_unit(struct adapter * Adapter)
  *
  **********************************************************************/
 static void
-em_free_receive_structures(struct adapter * Adapter)
+em_free_receive_structures(struct adapter * adapter)
 {
    struct em_rx_buffer   *rx_buffer;
    int             i;
 
    INIT_DEBUGOUT("free_receive_structures: begin");
 
-   if (Adapter->rx_buffer_area != NULL) {
-      rx_buffer = Adapter->rx_buffer_area;
-      for (i = 0; i < Adapter->NumRxDescriptors; i++, rx_buffer++) {
-         if (rx_buffer->Packet != NULL)
-            m_freem(rx_buffer->Packet);
-         rx_buffer->Packet = NULL;
+   if (adapter->rx_buffer_area != NULL) {
+      rx_buffer = adapter->rx_buffer_area;
+      for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
+         if (rx_buffer->m_head != NULL)
+            m_freem(rx_buffer->m_head);
+         rx_buffer->m_head = NULL;
       }
    }
-   if (Adapter->rx_buffer_area != NULL) {
-      free(Adapter->rx_buffer_area, M_DEVBUF);
-      Adapter->rx_buffer_area = NULL;
+   if (adapter->rx_buffer_area != NULL) {
+      free(adapter->rx_buffer_area, M_DEVBUF);
+      adapter->rx_buffer_area = NULL;
    }
    return;
 }
@@ -1783,148 +1794,147 @@ em_free_receive_structures(struct adapter * Adapter)
  *
  *********************************************************************/
 static void
-em_process_receive_interrupts(struct adapter * Adapter)
+em_process_receive_interrupts(struct adapter * adapter)
 {
    struct mbuf         *mp;
    struct ifnet        *ifp;
    struct ether_header *eh;
-   u_int16_t           Length;
-   u_int8_t            LastByte;
-   u_int8_t            AcceptFrame = 0;
-   u_int8_t            EndOfPacket = 0;
-   u_int32_t           PacketLength = 0;
+   u_int16_t           len;
+   u_int8_t            last_byte;
+   u_int8_t            accept_frame = 0;
+   u_int8_t            eop = 0;
+   u_int32_t           pkt_len = 0;
 
    /* Pointer to the receive descriptor being examined. */
-   struct em_rx_desc * CurrentDescriptor;
-   struct em_rx_desc * LastDescriptorProcessed;
-   struct em_rx_buffer   *rx_buffer;
+   struct em_rx_desc   *current_desc;
+   struct em_rx_desc   *last_desc_processed;
+   struct em_rx_buffer *rx_buffer;
 
-   TXRX_DEBUGOUT("em_process_receive_interrupts: begin");
+   ifp = &adapter->interface_data.ac_if;
+   current_desc = adapter->next_rx_desc_to_check;
 
-   ifp = &Adapter->interface_data.ac_if;
-   CurrentDescriptor = Adapter->NextRxDescriptorToCheck;
-
-   if (!((CurrentDescriptor->status) & E1000_RXD_STAT_DD)) {
+   if (!((current_desc->status) & E1000_RXD_STAT_DD)) {
 #ifdef DBG_STATS
-      Adapter->NoPacketsAvail++;
+      adapter->no_pkts_avail++;
 #endif
       return;
    }
    
-   while (CurrentDescriptor->status & E1000_RXD_STAT_DD) {
+   while (current_desc->status & E1000_RXD_STAT_DD) {
 
       /* Get a pointer to the actual receive buffer */
-      rx_buffer = STAILQ_FIRST(&Adapter->RxSwPacketList);
+      rx_buffer = STAILQ_FIRST(&adapter->rx_buffer_list);
 
       if(rx_buffer == NULL) {
-         printf("em%d: Found null rx_buffer\n", Adapter->unit);
+         printf("em%d: Found null rx_buffer\n", adapter->unit);
          return;
       }
 
-      mp = rx_buffer->Packet;      
-      AcceptFrame = 1;
+      mp = rx_buffer->m_head;      
+      accept_frame = 1;
 
-      if (CurrentDescriptor->status & E1000_RXD_STAT_EOP) {
-         EndOfPacket = 1;
-         Length = CurrentDescriptor->length - ETHER_CRC_LEN;
+      if (current_desc->status & E1000_RXD_STAT_EOP) {
+         eop = 1;
+         len = current_desc->length - ETHER_CRC_LEN;
       }
       else {
-         EndOfPacket = 0;
-         Length = CurrentDescriptor->length;
+         eop = 0;
+         len = current_desc->length;
       }
 
-      if(CurrentDescriptor->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
+      if(current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
          
          /* Compute packet length for tbi_accept macro */
-         PacketLength = CurrentDescriptor->length;
-         if (Adapter->fmp != NULL) {
-            PacketLength += Adapter->fmp->m_pkthdr.len; 
+         pkt_len = current_desc->length;
+         if (adapter->fmp != NULL) {
+            pkt_len += adapter->fmp->m_pkthdr.len; 
          }
 
-         LastByte = *(mtod(rx_buffer->Packet,caddr_t) + CurrentDescriptor->length - 1);
+         last_byte = *(mtod(rx_buffer->m_head,caddr_t) + current_desc->length - 1);
 
-         if (TBI_ACCEPT(&Adapter->shared, 0, CurrentDescriptor->errors, 
-                        PacketLength, LastByte)) {  
-            PacketLength = em_tbi_adjust_stats(&Adapter->shared, &Adapter->stats, 
-                                               PacketLength, Adapter->shared.mac_addr);
-            Length--;
+         if (TBI_ACCEPT(&adapter->shared, current_desc->status, 
+                        current_desc->errors, 
+                        pkt_len, last_byte)) {  
+            pkt_len = em_tbi_adjust_stats(&adapter->shared, &adapter->stats, 
+                                               pkt_len, adapter->shared.mac_addr);
+            len--;
          } else {  
-            AcceptFrame = 0;
+            accept_frame = 0;
          }
       }
 
-      if (AcceptFrame) {
+      if (accept_frame) {
 
-         if (em_get_buf(rx_buffer, Adapter, NULL) == ENOBUFS) {
-            Adapter->DroppedPackets++;
-            em_get_buf(rx_buffer, Adapter, mp);
-            if(Adapter->fmp != NULL) m_freem(Adapter->fmp);
-            Adapter->fmp = NULL;
-            Adapter->lmp = NULL;
+         if (em_get_buf(rx_buffer, adapter, NULL) == ENOBUFS) {
+            adapter->dropped_pkts++;
+            em_get_buf(rx_buffer, adapter, mp);
+            if(adapter->fmp != NULL) m_freem(adapter->fmp);
+            adapter->fmp = NULL;
+            adapter->lmp = NULL;
             break;
          }
 
          /* Assign correct length to the current fragment */
-         mp->m_len = Length;
+         mp->m_len = len;
 
-         if(Adapter->fmp == NULL) {
-            mp->m_pkthdr.len = Length;
-            Adapter->fmp = mp;       /* Store the first mbuf */
-            Adapter->lmp = mp;
+         if(adapter->fmp == NULL) {
+            mp->m_pkthdr.len = len;
+            adapter->fmp = mp;       /* Store the first mbuf */
+            adapter->lmp = mp;
          }
          else {
             /* Chain mbuf's together */
             mp->m_flags &= ~M_PKTHDR;
-            Adapter->lmp->m_next = mp;
-            Adapter->lmp = Adapter->lmp->m_next;
-            Adapter->fmp->m_pkthdr.len += Length;
+            adapter->lmp->m_next = mp;
+            adapter->lmp = adapter->lmp->m_next;
+            adapter->fmp->m_pkthdr.len += len;
          }
 
-         if (EndOfPacket) {
-            Adapter->fmp->m_pkthdr.rcvif = ifp;
+         if (eop) {
+            adapter->fmp->m_pkthdr.rcvif = ifp;
 
-            eh = mtod(Adapter->fmp, struct ether_header *);
+            eh = mtod(adapter->fmp, struct ether_header *);
 
             /* Remove ethernet header from mbuf */
-            m_adj(Adapter->fmp, sizeof(struct ether_header));
-            em_receive_checksum(Adapter, CurrentDescriptor, Adapter->fmp);
-            ether_input(ifp, eh, Adapter->fmp);
+            m_adj(adapter->fmp, sizeof(struct ether_header));
+            em_receive_checksum(adapter, current_desc, adapter->fmp);
+            ether_input(ifp, eh, adapter->fmp);
       
-            Adapter->fmp = NULL;
-            Adapter->lmp = NULL;
+            adapter->fmp = NULL;
+            adapter->lmp = NULL;
          }
       } else {
-         Adapter->DroppedPackets++;
-         em_get_buf(rx_buffer, Adapter, mp);
-         if(Adapter->fmp != NULL) m_freem(Adapter->fmp);
-         Adapter->fmp = NULL;
-         Adapter->lmp = NULL;
+         adapter->dropped_pkts++;
+         em_get_buf(rx_buffer, adapter, mp);
+         if(adapter->fmp != NULL) m_freem(adapter->fmp);
+         adapter->fmp = NULL;
+         adapter->lmp = NULL;
       }
       
       /* Zero out the receive descriptors status  */
-      CurrentDescriptor->status = 0;
+      current_desc->status = 0;
       
-      if (rx_buffer->Packet != NULL) {
-         CurrentDescriptor->buffer_addr = rx_buffer->LowPhysicalAddress;
+      if (rx_buffer->m_head != NULL) {
+         current_desc->buffer_addr = rx_buffer->buffer_addr;
       }
 
       /* Advance our pointers to the next descriptor (checking for wrap). */
-      if (CurrentDescriptor == Adapter->LastRxDescriptor)
-         Adapter->NextRxDescriptorToCheck = Adapter->FirstRxDescriptor;
+      if (current_desc == adapter->last_rx_desc)
+         adapter->next_rx_desc_to_check = adapter->first_rx_desc;
       else
-         ((Adapter)->NextRxDescriptorToCheck)++;
+         ((adapter)->next_rx_desc_to_check)++;
 
-      LastDescriptorProcessed = CurrentDescriptor;
-      CurrentDescriptor = Adapter->NextRxDescriptorToCheck;
+      last_desc_processed = current_desc;
+      current_desc = adapter->next_rx_desc_to_check;
       /* 
        * Put the buffer that we just indicated back at the end of our list
        */
-      STAILQ_REMOVE_HEAD(&Adapter->RxSwPacketList, em_rx_entry);
-      STAILQ_INSERT_TAIL(&Adapter->RxSwPacketList, rx_buffer, em_rx_entry);
+      STAILQ_REMOVE_HEAD(&adapter->rx_buffer_list, em_rx_entry);
+      STAILQ_INSERT_TAIL(&adapter->rx_buffer_list, rx_buffer, em_rx_entry);
 
       /* Advance the E1000's Receive Queue #0  "Tail Pointer". */
-      E1000_WRITE_REG(&Adapter->shared, RDT, (((u_int32_t) LastDescriptorProcessed -
-                        (u_int32_t) Adapter->FirstRxDescriptor) >> 4));
+      E1000_WRITE_REG(&adapter->shared, RDT, (((u_int32_t) last_desc_processed -
+                        (u_int32_t) adapter->first_rx_desc) >> 4));
    }
    return;
 }
@@ -1937,76 +1947,62 @@ em_process_receive_interrupts(struct adapter * Adapter)
  *
  *********************************************************************/
 static void
-em_receive_checksum(struct adapter * Adapter,
-           struct em_rx_desc * RxDescriptor,
-           struct mbuf *mp)
+em_receive_checksum(struct adapter *adapter,
+                    struct em_rx_desc *rx_desc,
+                    struct mbuf *mp)
 {
    /* 82543 or newer only */
-   if((Adapter->shared.mac_type < em_82543) ||
+   if((adapter->shared.mac_type < em_82543) ||
       /* Ignore Checksum bit is set */
-      (RxDescriptor->status & E1000_RXD_STAT_IXSM)) {
-      RXCSUM_DEBUGOUT("Ignoring checksum");
+      (rx_desc->status & E1000_RXD_STAT_IXSM)) {
       mp->m_pkthdr.csum_flags = 0;
       return;
    }
 
-   if (RxDescriptor->status & E1000_RXD_STAT_IPCS) {
+   if (rx_desc->status & E1000_RXD_STAT_IPCS) {
       /* Did it pass? */
-      if (!(RxDescriptor->errors & E1000_RXD_ERR_IPE)) {
+      if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) {
          /* IP Checksum Good */
-         RXCSUM_DEBUGOUT("Good IP checksum");
          mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
          mp->m_pkthdr.csum_flags |= CSUM_IP_VALID;
 
       }
       else {
-         RXCSUM_DEBUGOUT("Bad IP checksum");
          mp->m_pkthdr.csum_flags = 0;
       }
    }
-   else {
-      RXCSUM_DEBUGOUT("IP Checksum not verified");
-   }
 
-   if (RxDescriptor->status & E1000_RXD_STAT_TCPCS) {
+   if (rx_desc->status & E1000_RXD_STAT_TCPCS) {
       /* Did it pass? */        
-      if (!(RxDescriptor->errors & E1000_RXD_ERR_TCPE)) {
-         RXCSUM_DEBUGOUT("Good TCP/UDP checksum");
+      if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) {
          mp->m_pkthdr.csum_flags |= (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
          mp->m_pkthdr.csum_data = htons(0xffff);
       }
-      else {
-         RXCSUM_DEBUGOUT("Bad TCP/UDP checksum");
-      }
-   }
-   else {
-      RXCSUM_DEBUGOUT("TCP/UDP checksum not verified");
    }
 
-
    return;
 }
 
 
 static void
-EnableInterrupts(struct adapter * Adapter)
+em_enable_intr(struct adapter * adapter)
 {
-   E1000_WRITE_REG(&Adapter->shared, IMS, (IMS_ENABLE_MASK));
+   E1000_WRITE_REG(&adapter->shared, IMS, (IMS_ENABLE_MASK));
    return;
 }
 
 static void
-DisableInterrupts(struct adapter * Adapter)
+em_disable_intr(struct adapter * adapter)
 {
-   E1000_WRITE_REG(&Adapter->shared, IMC, (0xffffffff & ~E1000_IMC_RXSEQ));
+   E1000_WRITE_REG(&adapter->shared, IMC, (0xffffffff & ~E1000_IMC_RXSEQ));
    return;
 }
 
-void em_write_pci_cfg(struct em_shared_adapter *Adapter,
+void em_write_pci_cfg(struct em_shared_adapter *adapter,
                       uint32_t reg,
                       uint16_t * value)
 {
-   pci_write_config(((struct em_osdep *)Adapter->back)->dev, reg, *value, 2);
+   pci_write_config(((struct em_osdep *)adapter->back)->dev, reg, *value, 2);
 }
 
 
@@ -2016,96 +2012,96 @@ void em_write_pci_cfg(struct em_shared_adapter *Adapter,
  *
  **********************************************************************/
 static void
-em_update_stats_counters(struct adapter * Adapter)
+em_update_stats_counters(struct adapter * adapter)
 {
    struct ifnet   *ifp;
 
-   Adapter->stats.crcerrs += E1000_READ_REG(&Adapter->shared, CRCERRS);
-   Adapter->stats.symerrs += E1000_READ_REG(&Adapter->shared, SYMERRS);
-   Adapter->stats.mpc += E1000_READ_REG(&Adapter->shared, MPC);
-   Adapter->stats.scc += E1000_READ_REG(&Adapter->shared, SCC);
-   Adapter->stats.ecol += E1000_READ_REG(&Adapter->shared, ECOL);
-   Adapter->stats.mcc += E1000_READ_REG(&Adapter->shared, MCC);
-   Adapter->stats.latecol += E1000_READ_REG(&Adapter->shared, LATECOL);
-   Adapter->stats.colc += E1000_READ_REG(&Adapter->shared, COLC);
-   Adapter->stats.dc += E1000_READ_REG(&Adapter->shared, DC);
-   Adapter->stats.sec += E1000_READ_REG(&Adapter->shared, SEC);
-   Adapter->stats.rlec += E1000_READ_REG(&Adapter->shared, RLEC);
-   Adapter->stats.xonrxc += E1000_READ_REG(&Adapter->shared, XONRXC);
-   Adapter->stats.xontxc += E1000_READ_REG(&Adapter->shared, XONTXC);
-   Adapter->stats.xoffrxc += E1000_READ_REG(&Adapter->shared, XOFFRXC);
-   Adapter->stats.xofftxc += E1000_READ_REG(&Adapter->shared, XOFFTXC);
-   Adapter->stats.fcruc += E1000_READ_REG(&Adapter->shared, FCRUC);
-   Adapter->stats.prc64 += E1000_READ_REG(&Adapter->shared, PRC64);
-   Adapter->stats.prc127 += E1000_READ_REG(&Adapter->shared, PRC127);
-   Adapter->stats.prc255 += E1000_READ_REG(&Adapter->shared, PRC255);
-   Adapter->stats.prc511 += E1000_READ_REG(&Adapter->shared, PRC511);
-   Adapter->stats.prc1023 += E1000_READ_REG(&Adapter->shared, PRC1023);
-   Adapter->stats.prc1522 += E1000_READ_REG(&Adapter->shared, PRC1522);
-   Adapter->stats.gprc += E1000_READ_REG(&Adapter->shared, GPRC);
-   Adapter->stats.bprc += E1000_READ_REG(&Adapter->shared, BPRC);
-   Adapter->stats.mprc += E1000_READ_REG(&Adapter->shared, MPRC);
-   Adapter->stats.gptc += E1000_READ_REG(&Adapter->shared, GPTC);
+   adapter->stats.crcerrs += E1000_READ_REG(&adapter->shared, CRCERRS);
+   adapter->stats.symerrs += E1000_READ_REG(&adapter->shared, SYMERRS);
+   adapter->stats.mpc += E1000_READ_REG(&adapter->shared, MPC);
+   adapter->stats.scc += E1000_READ_REG(&adapter->shared, SCC);
+   adapter->stats.ecol += E1000_READ_REG(&adapter->shared, ECOL);
+   adapter->stats.mcc += E1000_READ_REG(&adapter->shared, MCC);
+   adapter->stats.latecol += E1000_READ_REG(&adapter->shared, LATECOL);
+   adapter->stats.colc += E1000_READ_REG(&adapter->shared, COLC);
+   adapter->stats.dc += E1000_READ_REG(&adapter->shared, DC);
+   adapter->stats.sec += E1000_READ_REG(&adapter->shared, SEC);
+   adapter->stats.rlec += E1000_READ_REG(&adapter->shared, RLEC);
+   adapter->stats.xonrxc += E1000_READ_REG(&adapter->shared, XONRXC);
+   adapter->stats.xontxc += E1000_READ_REG(&adapter->shared, XONTXC);
+   adapter->stats.xoffrxc += E1000_READ_REG(&adapter->shared, XOFFRXC);
+   adapter->stats.xofftxc += E1000_READ_REG(&adapter->shared, XOFFTXC);
+   adapter->stats.fcruc += E1000_READ_REG(&adapter->shared, FCRUC);
+   adapter->stats.prc64 += E1000_READ_REG(&adapter->shared, PRC64);
+   adapter->stats.prc127 += E1000_READ_REG(&adapter->shared, PRC127);
+   adapter->stats.prc255 += E1000_READ_REG(&adapter->shared, PRC255);
+   adapter->stats.prc511 += E1000_READ_REG(&adapter->shared, PRC511);
+   adapter->stats.prc1023 += E1000_READ_REG(&adapter->shared, PRC1023);
+   adapter->stats.prc1522 += E1000_READ_REG(&adapter->shared, PRC1522);
+   adapter->stats.gprc += E1000_READ_REG(&adapter->shared, GPRC);
+   adapter->stats.bprc += E1000_READ_REG(&adapter->shared, BPRC);
+   adapter->stats.mprc += E1000_READ_REG(&adapter->shared, MPRC);
+   adapter->stats.gptc += E1000_READ_REG(&adapter->shared, GPTC);
 
    /* 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->shared, GORCL); 
-   Adapter->stats.gorch += E1000_READ_REG(&Adapter->shared, GORCH);
-   Adapter->stats.gotcl += E1000_READ_REG(&Adapter->shared, GOTCL);
-   Adapter->stats.gotch += E1000_READ_REG(&Adapter->shared, GOTCH);
-
-   Adapter->stats.rnbc += E1000_READ_REG(&Adapter->shared, RNBC);
-   Adapter->stats.ruc += E1000_READ_REG(&Adapter->shared, RUC);
-   Adapter->stats.rfc += E1000_READ_REG(&Adapter->shared, RFC);
-   Adapter->stats.roc += E1000_READ_REG(&Adapter->shared, ROC);
-   Adapter->stats.rjc += E1000_READ_REG(&Adapter->shared, RJC);
-
-   Adapter->stats.torl += E1000_READ_REG(&Adapter->shared, TORL);
-   Adapter->stats.torh += E1000_READ_REG(&Adapter->shared, TORH);
-   Adapter->stats.totl += E1000_READ_REG(&Adapter->shared, TOTL);
-   Adapter->stats.toth += E1000_READ_REG(&Adapter->shared, TOTH);
-
-   Adapter->stats.tpr += E1000_READ_REG(&Adapter->shared, TPR);
-   Adapter->stats.tpt += E1000_READ_REG(&Adapter->shared, TPT);
-   Adapter->stats.ptc64 += E1000_READ_REG(&Adapter->shared, PTC64);
-   Adapter->stats.ptc127 += E1000_READ_REG(&Adapter->shared, PTC127);
-   Adapter->stats.ptc255 += E1000_READ_REG(&Adapter->shared, PTC255);
-   Adapter->stats.ptc511 += E1000_READ_REG(&Adapter->shared, PTC511);
-   Adapter->stats.ptc1023 += E1000_READ_REG(&Adapter->shared, PTC1023);
-   Adapter->stats.ptc1522 += E1000_READ_REG(&Adapter->shared, PTC1522);
-   Adapter->stats.mptc += E1000_READ_REG(&Adapter->shared, MPTC);
-   Adapter->stats.bptc += E1000_READ_REG(&Adapter->shared, BPTC);
-
-   if (Adapter->shared.mac_type >= em_82543) {
-      Adapter->stats.algnerrc += E1000_READ_REG(&Adapter->shared, ALGNERRC);
-      Adapter->stats.rxerrc += E1000_READ_REG(&Adapter->shared, RXERRC);
-      Adapter->stats.tncrs += E1000_READ_REG(&Adapter->shared, TNCRS);
-      Adapter->stats.cexterr += E1000_READ_REG(&Adapter->shared, CEXTERR);
-      Adapter->stats.tsctc += E1000_READ_REG(&Adapter->shared, TSCTC);
-      Adapter->stats.tsctfc += E1000_READ_REG(&Adapter->shared, TSCTFC);
+   adapter->stats.gorcl += E1000_READ_REG(&adapter->shared, GORCL); 
+   adapter->stats.gorch += E1000_READ_REG(&adapter->shared, GORCH);
+   adapter->stats.gotcl += E1000_READ_REG(&adapter->shared, GOTCL);
+   adapter->stats.gotch += E1000_READ_REG(&adapter->shared, GOTCH);
+
+   adapter->stats.rnbc += E1000_READ_REG(&adapter->shared, RNBC);
+   adapter->stats.ruc += E1000_READ_REG(&adapter->shared, RUC);
+   adapter->stats.rfc += E1000_READ_REG(&adapter->shared, RFC);
+   adapter->stats.roc += E1000_READ_REG(&adapter->shared, ROC);
+   adapter->stats.rjc += E1000_READ_REG(&adapter->shared, RJC);
+
+   adapter->stats.torl += E1000_READ_REG(&adapter->shared, TORL);
+   adapter->stats.torh += E1000_READ_REG(&adapter->shared, TORH);
+   adapter->stats.totl += E1000_READ_REG(&adapter->shared, TOTL);
+   adapter->stats.toth += E1000_READ_REG(&adapter->shared, TOTH);
+
+   adapter->stats.tpr += E1000_READ_REG(&adapter->shared, TPR);
+   adapter->stats.tpt += E1000_READ_REG(&adapter->shared, TPT);
+   adapter->stats.ptc64 += E1000_READ_REG(&adapter->shared, PTC64);
+   adapter->stats.ptc127 += E1000_READ_REG(&adapter->shared, PTC127);
+   adapter->stats.ptc255 += E1000_READ_REG(&adapter->shared, PTC255);
+   adapter->stats.ptc511 += E1000_READ_REG(&adapter->shared, PTC511);
+   adapter->stats.ptc1023 += E1000_READ_REG(&adapter->shared, PTC1023);
+   adapter->stats.ptc1522 += E1000_READ_REG(&adapter->shared, PTC1522);
+   adapter->stats.mptc += E1000_READ_REG(&adapter->shared, MPTC);
+   adapter->stats.bptc += E1000_READ_REG(&adapter->shared, BPTC);
+
+   if (adapter->shared.mac_type >= em_82543) {
+      adapter->stats.algnerrc += E1000_READ_REG(&adapter->shared, ALGNERRC);
+      adapter->stats.rxerrc += E1000_READ_REG(&adapter->shared, RXERRC);
+      adapter->stats.tncrs += E1000_READ_REG(&adapter->shared, TNCRS);
+      adapter->stats.cexterr += E1000_READ_REG(&adapter->shared, CEXTERR);
+      adapter->stats.tsctc += E1000_READ_REG(&adapter->shared, TSCTC);
+      adapter->stats.tsctfc += E1000_READ_REG(&adapter->shared, TSCTFC);
    }
-   ifp = &Adapter->interface_data.ac_if;
+   ifp = &adapter->interface_data.ac_if;
 
    /* Fill out the OS statistics structure */
-   ifp->if_ipackets = Adapter->stats.gprc;
-   ifp->if_opackets = Adapter->stats.gptc;
-   ifp->if_ibytes = Adapter->stats.gorcl;
-   ifp->if_obytes = Adapter->stats.gotcl;
-   ifp->if_imcasts = Adapter->stats.mprc;
-   ifp->if_collisions = Adapter->stats.colc;
+   ifp->if_ipackets = adapter->stats.gprc;
+   ifp->if_opackets = adapter->stats.gptc;
+   ifp->if_ibytes = adapter->stats.gorcl;
+   ifp->if_obytes = adapter->stats.gotcl;
+   ifp->if_imcasts = adapter->stats.mprc;
+   ifp->if_collisions = adapter->stats.colc;
 
    /* Rx Errors */
    ifp->if_ierrors =
-      Adapter->DroppedPackets +
-      Adapter->stats.rxerrc +
-      Adapter->stats.crcerrs +
-      Adapter->stats.algnerrc +
-      Adapter->stats.rlec + Adapter->stats.rnbc + 
-      Adapter->stats.mpc + Adapter->stats.cexterr;
+      adapter->dropped_pkts +
+      adapter->stats.rxerrc +
+      adapter->stats.crcerrs +
+      adapter->stats.algnerrc +
+      adapter->stats.rlec + adapter->stats.rnbc + 
+      adapter->stats.mpc + adapter->stats.cexterr;
 
    /* Tx Errors */
-   ifp->if_oerrors = Adapter->stats.ecol + Adapter->stats.latecol;
+   ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol;
 
 }
 
@@ -2118,43 +2114,42 @@ em_update_stats_counters(struct adapter * Adapter)
  *
  **********************************************************************/
 static void
-em_print_hw_stats(struct adapter * Adapter)
+em_print_hw_stats(struct adapter * adapter)
 {
-   int unit = Adapter->unit;
+   int unit = adapter->unit;
 
 #ifdef DBG_STATS
-   printf("em%d: Tx Descriptors not Avail = %ld\n", unit, Adapter->NoTxDescAvail);
-   printf("em%d: Packets not Avail = %ld\n", unit, Adapter->NoPacketsAvail);
-   printf("em%d: CleanTxInterrupts = %ld\n", unit, Adapter->CleanTxInterrupts);
-   printf("em%d: Tx Buffer not avail1 = %ld\n", unit, Adapter->NoTxBufferAvail1);
-   printf("em%d: Tx Buffer not avail2 = %ld\n", unit, Adapter->NoTxBufferAvail2);
+   printf("em%d: Packets not Avail = %ld\n", unit, adapter->no_pkts_avail);
+   printf("em%d: clean_tx_interrupts = %ld\n", unit, adapter->clean_tx_interrupts); 
 #endif
-   printf("em%d: No Jumbo Buffer Avail = %ld\n",unit, Adapter->NoJumboBufAvail);
-   printf("em%d: Jumbo Mbuf Failed = %ld\n",unit, Adapter->JumboMbufFailed);
-   printf("em%d: Jumbo Cluster Failed = %ld\n",unit, Adapter->JumboClusterFailed);
-   printf("em%d: Std Mbuf Failed = %ld\n",unit, Adapter->StdMbufFailed);
-   printf("em%d: Std Cluster Failed = %ld\n",unit, Adapter->StdClusterFailed);
-
-   printf("em%d: Symbol errors = %lld\n", unit, Adapter->stats.symerrs);
-   printf("em%d: Sequence errors = %lld\n", unit, Adapter->stats.sec);
-   printf("em%d: Defer count = %lld\n", unit, Adapter->stats.dc);
-
-   printf("em%d: Missed Packets = %lld\n", unit, Adapter->stats.mpc);
-   printf("em%d: Receive No Buffers = %lld\n", unit, Adapter->stats.rnbc);
-   printf("em%d: Receive length errors = %lld\n", unit, Adapter->stats.rlec);
-   printf("em%d: Receive errors = %lld\n", unit, Adapter->stats.rxerrc);
-   printf("em%d: Crc errors = %lld\n", unit, Adapter->stats.crcerrs);
-   printf("em%d: Alignment errors = %lld\n", unit, Adapter->stats.algnerrc);
-   printf("em%d: Carrier extension errors = %lld\n", unit, Adapter->stats.cexterr);
-   printf("em%d: Driver dropped packets = %ld\n", unit, Adapter->DroppedPackets);
-
-   printf("em%d: XON Rcvd = %lld\n", unit, Adapter->stats.xonrxc);
-   printf("em%d: XON Xmtd = %lld\n", unit, Adapter->stats.xontxc);
-   printf("em%d: XOFF Rcvd = %lld\n", unit, Adapter->stats.xoffrxc);
-   printf("em%d: XOFF Xmtd = %lld\n", unit, Adapter->stats.xofftxc);
-
-   printf("em%d: Good Packets Rcvd = %lld\n", unit, Adapter->stats.gprc);
-   printf("em%d: Good Packets Xmtd = %lld\n", unit, Adapter->stats.gptc);
+   
+   printf("em%d: Tx Descriptors not Avail = %ld\n", unit, adapter->no_tx_desc_avail);
+   printf("em%d: Tx Buffer not avail1 = %ld\n", unit, adapter->no_tx_buffer_avail1);
+   printf("em%d: Tx Buffer not avail2 = %ld\n", unit, adapter->no_tx_buffer_avail2);
+   printf("em%d: Std Mbuf Failed = %ld\n",unit, adapter->mbuf_alloc_failed);
+   printf("em%d: Std Cluster Failed = %ld\n",unit, adapter->mbuf_cluster_failed);
+   printf("em%d: Xmit Pullup = %ld\n",unit, adapter->xmit_pullup);
+
+   printf("em%d: Symbol errors = %lld\n", unit, adapter->stats.symerrs);
+   printf("em%d: Sequence errors = %lld\n", unit, adapter->stats.sec);
+   printf("em%d: Defer count = %lld\n", unit, adapter->stats.dc);
+
+   printf("em%d: Missed Packets = %lld\n", unit, adapter->stats.mpc);
+   printf("em%d: Receive No Buffers = %lld\n", unit, adapter->stats.rnbc);
+   printf("em%d: Receive length errors = %lld\n", unit, adapter->stats.rlec);
+   printf("em%d: Receive errors = %lld\n", unit, adapter->stats.rxerrc);
+   printf("em%d: Crc errors = %lld\n", unit, adapter->stats.crcerrs);
+   printf("em%d: Alignment errors = %lld\n", unit, adapter->stats.algnerrc);
+   printf("em%d: Carrier extension errors = %lld\n", unit, adapter->stats.cexterr);
+   printf("em%d: Driver dropped packets = %ld\n", unit, adapter->dropped_pkts);
+
+   printf("em%d: XON Rcvd = %lld\n", unit, adapter->stats.xonrxc);
+   printf("em%d: XON Xmtd = %lld\n", unit, adapter->stats.xontxc);
+   printf("em%d: XOFF Rcvd = %lld\n", unit, adapter->stats.xoffrxc);
+   printf("em%d: XOFF Xmtd = %lld\n", unit, adapter->stats.xofftxc);
+
+   printf("em%d: Good Packets Rcvd = %lld\n", unit, adapter->stats.gprc);
+   printf("em%d: Good Packets Xmtd = %lld\n", unit, adapter->stats.gptc);
 }
 
 
@@ -2166,21 +2161,21 @@ em_print_hw_stats(struct adapter * Adapter)
  *
  **********************************************************************/
 static void
-em_clean_transmit_interrupts(struct adapter * Adapter)
+em_clean_transmit_interrupts(struct adapter * adapter)
 {
    struct em_tx_buffer *tx_buffer;
-   struct em_tx_desc *TransmitDescriptor;
+   struct em_tx_desc   *tx_desc;
    int             s;
    struct ifnet   *ifp;
 
    s = splimp();
 #ifdef DBG_STATS
-   Adapter->CleanTxInterrupts++;
+   adapter->clean_tx_interrupts++;
 #endif
 
-   for (tx_buffer = STAILQ_FIRST(&Adapter->UsedSwTxPacketList);
+   for (tx_buffer = STAILQ_FIRST(&adapter->used_tx_buffer_list);
         tx_buffer; 
-        tx_buffer = STAILQ_FIRST(&Adapter->UsedSwTxPacketList)) {
+        tx_buffer = STAILQ_FIRST(&adapter->used_tx_buffer_list)) {
 
       /* 
        * Get hold of the next descriptor that the em will report status
@@ -2190,41 +2185,41 @@ em_clean_transmit_interrupts(struct adapter * Adapter)
        * last one then it is done with all of them.
        */
 
-      TransmitDescriptor = Adapter->OldestUsedTxDescriptor +
-         (tx_buffer->NumTxDescriptorsUsed - 1);
+      tx_desc = adapter->oldest_used_tx_desc +
+         (tx_buffer->num_tx_desc_used - 1);
 
       /* Check for wrap case */
-      if (TransmitDescriptor > Adapter->LastTxDescriptor)
-         TransmitDescriptor -= Adapter->NumTxDescriptors;
+      if (tx_desc > adapter->last_tx_desc)
+         tx_desc -= adapter->num_tx_desc;
 
 
       /* 
        * If the descriptor done bit is set free tx_buffer and associated
        * resources
        */
-      if (TransmitDescriptor->upper.fields.status &
+      if (tx_desc->upper.fields.status &
          E1000_TXD_STAT_DD) {
 
-         STAILQ_REMOVE_HEAD(&Adapter->UsedSwTxPacketList, em_tx_entry);
+         STAILQ_REMOVE_HEAD(&adapter->used_tx_buffer_list, em_tx_entry);
 
-         if ((TransmitDescriptor == Adapter->LastTxDescriptor))
-            Adapter->OldestUsedTxDescriptor =
-               Adapter->FirstTxDescriptor;
+         if ((tx_desc == adapter->last_tx_desc))
+            adapter->oldest_used_tx_desc =
+               adapter->first_tx_desc;
          else
-            Adapter->OldestUsedTxDescriptor = (TransmitDescriptor + 1);
+            adapter->oldest_used_tx_desc = (tx_desc + 1);
 
          /* Make available the descriptors that were previously used */
-         Adapter->NumTxDescriptorsAvail +=
-            tx_buffer->NumTxDescriptorsUsed;
+         adapter->num_tx_desc_avail +=
+            tx_buffer->num_tx_desc_used;
 
-         tx_buffer->NumTxDescriptorsUsed = 0;
+         tx_buffer->num_tx_desc_used = 0;
 
-         if (tx_buffer->Packet) {
-            m_freem(tx_buffer->Packet);
-            tx_buffer->Packet = NULL;
+         if (tx_buffer->m_head) {
+            m_freem(tx_buffer->m_head);
+            tx_buffer->m_head = NULL;
          }
          /* Return this "Software packet" back to the "free" list */
-         STAILQ_INSERT_TAIL(&Adapter->FreeSwTxPacketList, tx_buffer, em_tx_entry);
+         STAILQ_INSERT_TAIL(&adapter->free_tx_buffer_list, tx_buffer, em_tx_entry);
       } else {
          /* 
           * Found a tx_buffer that the em is not done with then there is
@@ -2234,10 +2229,10 @@ em_clean_transmit_interrupts(struct adapter * Adapter)
       }
    }                     /* end for each tx_buffer */
 
-   ifp = &Adapter->interface_data.ac_if;
+   ifp = &adapter->interface_data.ac_if;
 
    /* Tell the stack that it is OK to send packets */
-   if (Adapter->NumTxDescriptorsAvail > TX_CLEANUP_THRESHOLD) {
+   if (adapter->num_tx_desc_avail > TX_CLEANUP_THRESHOLD) {
       ifp->if_timer = 0;
       ifp->if_flags &= ~IFF_OACTIVE;
    }
diff --git a/sys/dev/em/if_em.h b/sys/dev/em/if_em.h
index f840183..f3859bd 100644
--- a/sys/dev/em/if_em.h
+++ b/sys/dev/em/if_em.h
@@ -1,6 +1,6 @@
 /**************************************************************************
 
-Copyright (c) 2001 Intel Corporation
+Copyright (c) 2001-2002 Intel Corporation
 All rights reserved.
 
 Redistribution and use in source and binary forms of the Software, with or
@@ -70,7 +70,6 @@ SUCH DAMAGE.
 #include <machine/clock.h>
 #include <pci/pcivar.h>
 #include <pci/pcireg.h>
-
 #include "opt_bdg.h"
 
 #include <dev/em/if_em_fxhw.h>
@@ -109,9 +108,6 @@ SUCH DAMAGE.
 #define DEBUG_INIT  0
 #define DEBUG_IOCTL 0
 #define DEBUG_HW    0
-#define DEBUG_TXRX  0
-#define DEBUG_RXCSUM 0
-#define DEBUG_TXCSUM 0
 
 #define INIT_DEBUGOUT(S)            if (DEBUG_INIT)  printf(S "\n")
 #define INIT_DEBUGOUT1(S, A)        if (DEBUG_INIT)  printf(S "\n", A)
@@ -122,24 +118,7 @@ SUCH DAMAGE.
 #define HW_DEBUGOUT(S)              if (DEBUG_HW) printf(S "\n")
 #define HW_DEBUGOUT1(S, A)          if (DEBUG_HW) printf(S "\n", A)
 #define HW_DEBUGOUT2(S, A, B)       if (DEBUG_HW) printf(S "\n", A, B)
-#define TXRX_DEBUGOUT(S)              if (DEBUG_TXRX) printf(S "\n")
-#define TXRX_DEBUGOUT1(S, A)          if (DEBUG_TXRX) printf(S "\n", A)
-#define TXRX_DEBUGOUT2(S, A, B)       if (DEBUG_TXRX) printf(S "\n", A, B)
-#define RXCSUM_DEBUGOUT(S)              if (DEBUG_RXCSUM) printf(S "\n")
-#define RXCSUM_DEBUGOUT1(S, A)          if (DEBUG_RXCSUM) printf(S "\n", A)
-#define RXCSUM_DEBUGOUT2(S, A, B)       if (DEBUG_RXCSUM) printf(S "\n", A, B)
-#define TXCSUM_DEBUGOUT(S)              if (DEBUG_TXCSUM) printf(S "\n")
-#define TXCSUM_DEBUGOUT1(S, A)          if (DEBUG_TXCSUM) printf(S "\n", A)
-#define TXCSUM_DEBUGOUT2(S, A, B)       if (DEBUG_TXCSUM) printf(S "\n", A, B)
-
-/* Device ID defines */
-#define PCI_DEVICE_ID_82542            0x1000
-#define PCI_DEVICE_ID_82543GC_FIBER    0x1001
-#define PCI_DEVICE_ID_82543GC_COPPER   0x1004
-#define PCI_DEVICE_ID_82544EI_FIBER    0x1009
-#define PCI_DEVICE_ID_82544EI_COPPER   0x1008
-#define PCI_DEVICE_ID_82544GC_STRG     0x100C
-#define PCI_DEVICE_ID_82544GC_COPPER   0x100D
+
 
 /* Supported RX Buffer Sizes */
 #define EM_RXBUFFER_2048        2048
@@ -147,6 +126,10 @@ SUCH DAMAGE.
 #define EM_RXBUFFER_8192        8192
 #define EM_RXBUFFER_16384      16384
 
+#ifdef __alpha__
+#undef vtophys
+#define vtophys(va)     alpha_XXX_dmamap((vm_offset_t)(va))
+#endif /* __alpha__ */
 
 /* ******************************************************************************
  * vendor_info_array
@@ -167,8 +150,8 @@ typedef struct _em_vendor_info_t
 
 struct em_tx_buffer {
         STAILQ_ENTRY(em_tx_buffer) em_tx_entry;
-        struct mbuf    *Packet;
-        u_int32_t       NumTxDescriptorsUsed;
+        struct mbuf    *m_head;
+        u_int32_t       num_tx_desc_used;
 };
 
 
@@ -178,9 +161,8 @@ struct em_tx_buffer {
  * ******************************************************************************/
 struct em_rx_buffer {
         STAILQ_ENTRY(em_rx_buffer) em_rx_entry;
-        struct mbuf    *Packet;
-        u_int32_t       LowPhysicalAddress;
-        u_int32_t       HighPhysicalAddress;
+        struct mbuf    *m_head;
+        u_int64_t      buffer_addr;
 };
 
 typedef enum _XSUM_CONTEXT_T {
@@ -206,53 +188,39 @@ struct adapter {
         struct callout_handle timer_handle;
         u_int8_t        unit;
 
-        /* PCI Info */
-        u_int16_t       VendorId;
-        u_int16_t       DeviceId;
-        u_int8_t        RevId;
-        u_int16_t       SubVendorId;
-        u_int16_t       SubSystemId;
-
-
         /* Info about the board itself */
-        uint8_t         PermNetAddress[ETH_LENGTH_OF_ADDRESS];
-        u_int32_t       PartNumber;
-
-        u_int8_t        MulticastAddressList[MAX_NUM_MULTICAST_ADDRESSES][ETH_LENGTH_OF_ADDRESS];
-        u_int8_t        LinkStatusChanged;
-        u_int8_t        LinkIsActive;
-        u_int16_t       LineSpeed;
-        u_int16_t       FullDuplex;
-        u_int32_t       TxIntDelay;
-        u_int32_t       RxIntDelay;
+        u_int32_t       part_num;
+        u_int8_t        link_active;
+        u_int16_t       link_speed;
+        u_int16_t       link_duplex;
+        u_int32_t       tx_int_delay;
+        u_int32_t       rx_int_delay;
 
-        u_int8_t        RxChecksum;
-        XSUM_CONTEXT_T  ActiveChecksumContext;
+        u_int8_t        rx_checksum;
+        XSUM_CONTEXT_T  active_checksum_context;
 
         /* Transmit definitions */
-        struct em_tx_desc *FirstTxDescriptor;
-        struct em_tx_desc *LastTxDescriptor;
-        struct em_tx_desc *NextAvailTxDescriptor;
-        struct em_tx_desc *OldestUsedTxDescriptor;
-        struct em_tx_desc *TxDescBase;
-        volatile u_int16_t NumTxDescriptorsAvail;
-        u_int16_t       NumTxDescriptors;
-        u_int32_t       TxdCmd;
+        struct em_tx_desc *first_tx_desc;
+        struct em_tx_desc *last_tx_desc;
+        struct em_tx_desc *next_avail_tx_desc;
+        struct em_tx_desc *oldest_used_tx_desc;
+        struct em_tx_desc *tx_desc_base;
+        volatile u_int16_t num_tx_desc_avail;
+        u_int16_t       num_tx_desc;
+        u_int32_t       txd_cmd;
         struct em_tx_buffer   *tx_buffer_area;
-        STAILQ_HEAD(__em_tx_buffer_free, em_tx_buffer)  FreeSwTxPacketList;
-        STAILQ_HEAD(__em_tx_buffer_used, em_tx_buffer)  UsedSwTxPacketList;
+        STAILQ_HEAD(__em_tx_buffer_free, em_tx_buffer)  free_tx_buffer_list;
+        STAILQ_HEAD(__em_tx_buffer_used, em_tx_buffer)  used_tx_buffer_list;
 
         /* Receive definitions */
-        struct em_rx_desc *FirstRxDescriptor;
-        struct em_rx_desc *LastRxDescriptor;
-        struct em_rx_desc *NextRxDescriptorToCheck;
-        struct em_rx_desc *RxDescBase;
-        u_int16_t       NumRxDescriptors;
-        u_int16_t       NumRxDescriptorsEmpty;
-        u_int16_t       NextRxDescriptorToFill;
-        u_int32_t       RxBufferLen;
+        struct em_rx_desc *first_rx_desc;
+        struct em_rx_desc *last_rx_desc;
+        struct em_rx_desc *next_rx_desc_to_check;
+        struct em_rx_desc *rx_desc_base;
+        u_int16_t       num_rx_desc;
+        u_int32_t       rx_buffer_len;
         struct em_rx_buffer   *rx_buffer_area;
-        STAILQ_HEAD(__em_rx_buffer, em_rx_buffer)  RxSwPacketList;
+        STAILQ_HEAD(__em_rx_buffer, em_rx_buffer)  rx_buffer_list;
 
         /* Jumbo frame */
         struct mbuf     *fmp;
@@ -260,18 +228,17 @@ struct adapter {
 
 
         /* Misc stats maintained by the driver */
-        unsigned long   DroppedPackets;
-        unsigned long   NoJumboBufAvail;
-        unsigned long   JumboMbufFailed;
-        unsigned long   JumboClusterFailed;
-        unsigned long   StdMbufFailed;
-        unsigned long   StdClusterFailed;
-#ifdef DBG_STATS
-        unsigned long   NoTxDescAvail;
-        unsigned long   NoPacketsAvail;
-        unsigned long   CleanTxInterrupts;
-        unsigned long   NoTxBufferAvail1;
-        unsigned long   NoTxBufferAvail2;
+        unsigned long   dropped_pkts;
+        unsigned long   mbuf_alloc_failed;
+        unsigned long   mbuf_cluster_failed;
+        unsigned long   xmit_pullup;
+        unsigned long   no_tx_desc_avail;
+        unsigned long   no_tx_buffer_avail1;
+        unsigned long   no_tx_buffer_avail2;
+#ifdef DBG_STATS 
+        unsigned long   no_pkts_avail;
+        unsigned long   clean_tx_interrupts;
+
 #endif
 
         struct em_shared_stats stats;
diff --git a/sys/dev/em/if_em_fxhw.c b/sys/dev/em/if_em_fxhw.c
index 04b6a72..71b7942 100644
--- a/sys/dev/em/if_em_fxhw.c
+++ b/sys/dev/em/if_em_fxhw.c
@@ -1,6 +1,6 @@
 /*******************************************************************************
 
-  Copyright (c) 2001 Intel Corporation 
+  Copyright (c) 2001-2002 Intel Corporation 
   All rights reserved. 
   
   Redistribution and use in source and binary forms of the Software, with or 
@@ -52,7 +52,7 @@ em_raise_clock(struct em_shared_adapter *shared,
                   uint32_t *eecd_reg)
 {
     /* Raise the clock input to the EEPROM (by setting the SK bit), and then
-     *  wait 50 microseconds.
+     * wait 50 microseconds.
      */
     *eecd_reg = *eecd_reg | E1000_EECD_SK;
     E1000_WRITE_REG(shared, EECD, *eecd_reg);
@@ -184,11 +184,11 @@ em_setup_eeprom(struct em_shared_adapter *shared)
 
     eecd_reg = E1000_READ_REG(shared, EECD);
 
-    /*  Clear SK and DI  */
+    /* Clear SK and DI */
     eecd_reg &= ~(E1000_EECD_SK | E1000_EECD_DI);
     E1000_WRITE_REG(shared, EECD, eecd_reg);
 
-    /*  Set CS  */
+    /* Set CS */
     eecd_reg |= E1000_EECD_CS;
     E1000_WRITE_REG(shared, EECD, eecd_reg);
     return;
@@ -206,22 +206,22 @@ em_standby_eeprom(struct em_shared_adapter *shared)
 
     eecd_reg = E1000_READ_REG(shared, EECD);
 
-    /*  Deselct EEPROM  */
+    /* Deselct EEPROM */
     eecd_reg &= ~(E1000_EECD_CS | E1000_EECD_SK);
     E1000_WRITE_REG(shared, EECD, eecd_reg);
     usec_delay(50);
 
-    /*  Clock high  */
+    /* Clock high */
     eecd_reg |= E1000_EECD_SK;
     E1000_WRITE_REG(shared, EECD, eecd_reg);
     usec_delay(50);
 
-    /*  Select EEPROM  */
+    /* Select EEPROM */
     eecd_reg |= E1000_EECD_CS;
     E1000_WRITE_REG(shared, EECD, eecd_reg);
     usec_delay(50);
 
-    /*  Clock low  */
+    /* Clock low */
     eecd_reg &= ~E1000_EECD_SK;
     E1000_WRITE_REG(shared, EECD, eecd_reg);
     usec_delay(50);
@@ -240,12 +240,12 @@ em_clock_eeprom(struct em_shared_adapter *shared)
 
     eecd_reg = E1000_READ_REG(shared, EECD);
 
-    /*  Rising edge of clock  */
+    /* Rising edge of clock */
     eecd_reg |= E1000_EECD_SK;
     E1000_WRITE_REG(shared, EECD, eecd_reg);
     usec_delay(50);
 
-    /*  Falling edge of clock  */
+    /* Falling edge of clock */
     eecd_reg &= ~E1000_EECD_SK;
     E1000_WRITE_REG(shared, EECD, eecd_reg);
     usec_delay(50);
@@ -347,33 +347,23 @@ em_force_mac_fc(struct em_shared_adapter *shared)
      */
 
     switch (shared->fc) {
-    case em_fc_none:        /* 0 */
-
+    case em_fc_none:
         ctrl_reg &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE));
         break;
-
-    case em_fc_rx_pause:    /* 1 */
-
+    case em_fc_rx_pause:
         ctrl_reg &= (~E1000_CTRL_TFCE);
         ctrl_reg |= E1000_CTRL_RFCE;
         break;
-
-    case em_fc_tx_pause:    /* 2 */
-
+    case em_fc_tx_pause:
         ctrl_reg &= (~E1000_CTRL_RFCE);
         ctrl_reg |= E1000_CTRL_TFCE;
         break;
-
-    case em_fc_full:        /* 3 */
-
+    case em_fc_full:
         ctrl_reg |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE);
         break;
-
     default:
-
         DEBUGOUT("Flow control param set incorrectly\n");
         ASSERT(0);
-
         break;
     }
 
@@ -397,6 +387,7 @@ em_adapter_stop(struct em_shared_adapter *shared)
 #if DBG
     uint32_t ctrl_reg;
 #endif
+    uint32_t ctrl_ext_reg;
     uint32_t icr_reg;
     uint16_t pci_cmd_word;
 
@@ -435,7 +426,7 @@ em_adapter_stop(struct em_shared_adapter *shared)
      * the global reset.
      */
     E1000_WRITE_REG(shared, RCTL, 0);
-    E1000_WRITE_REG(shared, TCTL, 0);
+    E1000_WRITE_REG(shared, TCTL, E1000_TCTL_PSP);
 
     /* The tbi_compatibility_on Flag must be cleared when Rctl is cleared. */
     shared->tbi_compatibility_on = FALSE;
@@ -460,6 +451,12 @@ em_adapter_stop(struct em_shared_adapter *shared)
     ASSERT(!(ctrl_reg & E1000_CTRL_RST));
 #endif
 
+    /* Force a reload from the EEPROM */
+    ctrl_ext_reg = E1000_READ_REG(shared, CTRL_EXT);
+    ctrl_ext_reg |= E1000_CTRL_EXT_EE_RST;
+    E1000_WRITE_REG(shared, CTRL_EXT, ctrl_ext_reg);
+    msec_delay(2);
+    
     /* Clear interrupt mask to stop board from generating interrupts */
     DEBUGOUT("Masking off all interrupts\n");
     E1000_WRITE_REG(shared, IMC, 0xffffffff);
@@ -567,12 +564,11 @@ em_init_hw(struct em_shared_adapter *shared)
      * is no link.
      */
     em_clear_hw_cntrs(shared);
-    
-    shared->large_eeprom = FALSE;
+
     shared->low_profile = FALSE;
     if(shared->mac_type == em_82544) {
-        i = em_read_eeprom(shared, E1000_EEPROM_LED_LOGIC);
-        if(i & E1000_EEPROM_SWDPIN0)
+        if(em_read_eeprom(shared, E1000_EEPROM_LED_LOGIC) & 
+           E1000_EEPROM_SWDPIN0)
             shared->low_profile = TRUE;
     }
 
@@ -920,10 +916,10 @@ em_setup_fc_and_link(struct em_shared_adapter *shared)
      * signal detection.  So this should be done before em_setup_pcs_link()
      * or em_phy_setup() is called.
      */
-    if(shared->mac_type >= em_82543) {
+    if(shared->mac_type == em_82543) {
         ctrl_ext_reg = ((eecd_reg & EEPROM_WORD0F_SWPDIO_EXT)
                         << SWDPIO__EXT_SHIFT);
-        E1000_WRITE_REG(shared, CTRLEXT, ctrl_ext_reg);
+        E1000_WRITE_REG(shared, CTRL_EXT, ctrl_ext_reg);
     }
 
     /* Call the necessary subroutine to configure the link. */
@@ -954,9 +950,9 @@ em_setup_fc_and_link(struct em_shared_adapter *shared)
         E1000_WRITE_REG(shared, FCRTL, 0);
         E1000_WRITE_REG(shared, FCRTH, 0);
     } else {
-       /* We need to set up the Receive Threshold high and low water
-        * marks as well as (optionally) enabling the transmission of XON frames.
-        */
+        /* We need to set up the Receive Threshold high and low water marks
+         * as well as (optionally) enabling the transmission of XON frames.
+         */
         if(shared->fc_send_xon) {
             E1000_WRITE_REG(shared, FCRTL,
                             (shared->fc_low_water | E1000_FCRTL_XONE));
@@ -1351,25 +1347,26 @@ em_check_for_link(struct em_shared_adapter *shared)
         case M88E1000_12_PHY_ID:
         case M88E1000_14_PHY_ID:
         case M88E1000_I_PHY_ID:
-              /* We have a M88E1000 PHY and Auto-Neg is enabled.  If we
-               * have Si on board that is 82544 or newer, Auto
-               * Speed Detection takes care of MAC speed/duplex
-               * configuration.  So we only need to configure Collision
-               * Distance in the MAC.  Otherwise, we need to force
-               * speed/duplex on the MAC to the current PHY speed/duplex
-               * settings.
-               */
+        case M88E1011_I_PHY_ID:
+            /* We have a M88E1000 PHY and Auto-Neg is enabled.  If we
+             * have Si on board that is 82544 or newer, Auto
+             * Speed Detection takes care of MAC speed/duplex
+             * configuration.  So we only need to configure Collision
+             * Distance in the MAC.  Otherwise, we need to force
+             * speed/duplex on the MAC to the current PHY speed/duplex
+             * settings.
+             */
             if(shared->mac_type >= em_82544) {
                 DEBUGOUT("CFL - Auto-Neg complete.");
                 DEBUGOUT("Configuring Collision Distance.");
                 em_config_collision_dist(shared);
             } else {
-                 /* Read the Phy Specific Status register to get the
-                  * resolved speed/duplex settings.  Then call
-                  * em_config_mac_to_phy which will retrieve
-                  * PHY register information and configure the MAC to
-                  * equal the negotiated speed/duplex.
-                  */
+                /* Read the Phy Specific Status register to get the
+                 * resolved speed/duplex settings.  Then call
+                 * em_config_mac_to_phy which will retrieve
+                 * PHY register information and configure the MAC to
+                 * equal the negotiated speed/duplex.
+                 */
                 phy_data = em_read_phy_reg(shared, 
                                               M88E1000_PHY_SPEC_STATUS);
 
@@ -1378,18 +1375,18 @@ em_check_for_link(struct em_shared_adapter *shared)
                 em_config_mac_to_phy(shared, phy_data);
             }
 
-              /* Configure Flow Control now that Auto-Neg has completed.
-               * We need to first restore the users desired Flow
-               * Control setting since we may have had to re-autoneg
-               * with a different link partner.
-               */
+            /* Configure Flow Control now that Auto-Neg has completed.
+             * We need to first restore the users desired Flow
+             * Control setting since we may have had to re-autoneg
+             * with a different link partner.
+             */
             em_config_fc_after_link_up(shared);
             break;
 
         default:
             DEBUGOUT("CFL - Invalid PHY detected.\r\n");
 
-        }                       /* end switch statement */
+        } /* end switch statement */
 
         /* At this point we know that we are on copper, link is up, 
          * and we are auto-neg'd.  These are pre-conditions for checking
@@ -1484,7 +1481,7 @@ em_check_for_link(struct em_shared_adapter *shared)
     }
 
     return;
-}                               /* CheckForLink */
+}
 
 /******************************************************************************
  * Clears all hardware statistics counters. 
@@ -1621,7 +1618,8 @@ em_get_speed_and_duplex(struct em_shared_adapter *shared,
 #if DBG
     if(shared->phy_id == M88E1000_12_PHY_ID ||
        shared->phy_id == M88E1000_14_PHY_ID ||
-       shared->phy_id == M88E1000_I_PHY_ID) {
+       shared->phy_id == M88E1000_I_PHY_ID  ||
+       shared->phy_id == M88E1011_I_PHY_ID) {
         /* read the phy specific status register */
         phy_data = em_read_phy_reg(shared, M88E1000_PHY_SPEC_STATUS);
         DEBUGOUT1("M88E1000 Phy Specific Status Reg contents = %x\n", phy_data);
@@ -1629,7 +1627,6 @@ em_get_speed_and_duplex(struct em_shared_adapter *shared,
         DEBUGOUT1("Phy MII Status Reg contents = %x\n", phy_data);
         DEBUGOUT1("Device Status Reg contents = %x\n", 
                   E1000_READ_REG(shared, STATUS));
-        /* DisplayMiiContents(Adapter, (uint8_t)Adapter->PhyAddress); */
     }
 #endif
     return;
@@ -1645,9 +1642,26 @@ uint16_t
 em_read_eeprom(struct em_shared_adapter *shared,
                   uint16_t offset)
 {
+    boolean_t large_eeprom = FALSE;
     uint16_t data;
+    uint32_t eecd_reg;
+    uint32_t tmp = 0;
 
+    if((shared->mac_type > em_82544) &&
+       (E1000_READ_REG(shared, EECD) & E1000_EECD_SIZE)) large_eeprom = TRUE;
     
+    /* Request EEPROM Access */
+    if(shared->mac_type > em_82544) {
+        E1000_WRITE_REG(shared, EECD, (uint32_t) E1000_EECD_REQ);
+        eecd_reg = E1000_READ_REG(shared, EECD);
+        while((!(eecd_reg & E1000_EECD_GNT)) && (tmp < 100)) {
+            tmp++;
+            usec_delay(5);
+            eecd_reg = E1000_READ_REG(shared, EECD);
+        }
+        if(!(eecd_reg & E1000_EECD_GNT)) return(FALSE);
+    }
+
     /*  Prepare the EEPROM for reading  */
     em_setup_eeprom(shared);
 
@@ -1656,17 +1670,21 @@ em_read_eeprom(struct em_shared_adapter *shared,
     /* If we have a 256 word EEPROM, there are 8 address bits
      * if we have a 64 word EEPROM, there are 6 address bits
      */
-    if(shared->large_eeprom) 
+    if(large_eeprom) 
         em_shift_out_bits(shared, offset, 8);
     else
         em_shift_out_bits(shared, offset, 6);
 
-    /*  Read the data  */
+    /* Read the data */
     data = em_shift_in_bits(shared);
 
-    /*  End this read operation  */
+    /* End this read operation */
     em_standby_eeprom(shared);
 
+    /* Stop requestiong EEPROM access */
+    if(shared->mac_type > em_82544)
+        E1000_WRITE_REG(shared, EECD, (uint32_t) 0);
+
     return (data);
 }
 
@@ -1732,47 +1750,75 @@ em_write_eeprom(struct em_shared_adapter *shared,
                    uint16_t offset,
                    uint16_t data)
 {
+    boolean_t large_eeprom = FALSE;
+    uint32_t eecd_reg;
+    uint32_t tmp = 0;
+
+    if((shared->mac_type > em_82544) &&
+       (E1000_READ_REG(shared, EECD) & E1000_EECD_SIZE)) large_eeprom = TRUE;
+    
+    /* Request EEPROM Access */
+    if(shared->mac_type > em_82544) {
+        E1000_WRITE_REG(shared, EECD, (uint32_t) E1000_EECD_REQ);
+        eecd_reg = E1000_READ_REG(shared, EECD);
+        while((!(eecd_reg & E1000_EECD_GNT)) && (tmp < 100)) {
+            tmp++;
+            usec_delay(5);
+            eecd_reg = E1000_READ_REG(shared, EECD);
+        }
+        if(!(eecd_reg & E1000_EECD_GNT)) return(FALSE);
+    }
 
-    /*  Prepare the EEPROM for writing  */
+    /* Prepare the EEPROM for writing  */
     em_setup_eeprom(shared);
 
-    /*  Send the 9-bit EWEN (write enable) command to the EEPROM (5-bit opcode
-     *  plus 4-bit dummy).  This puts the EEPROM into write/erase mode. 
+    /* Send the 9-bit (or 11-bit on large EEPROM) EWEN (write enable) 
+     * command to the EEPROM (5-bit opcode plus 4/6-bit dummy).
+     * This puts the EEPROM into write/erase mode. 
      */
     em_shift_out_bits(shared, EEPROM_EWEN_OPCODE, 5);
-    em_shift_out_bits(shared, 0, 4);
+    if(large_eeprom) 
+        em_shift_out_bits(shared, 0, 6);
+    else
+        em_shift_out_bits(shared, 0, 4);
 
-    /*  Prepare the EEPROM  */
+    /* Prepare the EEPROM */
     em_standby_eeprom(shared);
 
-    /*  Send the Write command (3-bit opcode + addr)  */
+    /* Send the Write command (3-bit opcode + addr) */
     em_shift_out_bits(shared, EEPROM_WRITE_OPCODE, 3);
     /* If we have a 256 word EEPROM, there are 8 address bits
      * if we have a 64 word EEPROM, there are 6 address bits
      */
-    if(shared->large_eeprom) 
+    if(large_eeprom) 
         em_shift_out_bits(shared, offset, 8);
     else
         em_shift_out_bits(shared, offset, 6);
 
-    /*  Send the data  */
+    /* Send the data */
     em_shift_out_bits(shared, data, 16);
-
     em_wait_eeprom_command(shared);
 
-    /*  Recover from write  */
+    /* Recover from write */
     em_standby_eeprom(shared);
 
-    /* Send the 9-bit EWDS (write disable) command to the EEPROM (5-bit
-     * opcode plus 4-bit dummy).  This takes the EEPROM out of write/erase
-     * mode.
+    /* Send the 9-bit  (or 11-bit on large EEPROM) EWDS (write disable) 
+     * command to the EEPROM (5-bit opcode plus 4/6-bit dummy).
+     * This takes the EEPROM out of write/erase mode.
      */
     em_shift_out_bits(shared, EEPROM_EWDS_OPCODE, 5);
-    em_shift_out_bits(shared, 0, 4);
+    if(large_eeprom) 
+        em_shift_out_bits(shared, 0, 6);
+    else
+        em_shift_out_bits(shared, 0, 4);
 
-    /*  Done with writing  */
+    /* Done with writing */
     em_cleanup_eeprom(shared);
 
+    /* Stop requestiong EEPROM access */
+    if(shared->mac_type > em_82544)
+        E1000_WRITE_REG(shared, EECD, (uint32_t) 0);
+
     return (TRUE);
 }
 
diff --git a/sys/dev/em/if_em_fxhw.h b/sys/dev/em/if_em_fxhw.h
index e31f3a6..15fb162 100644
--- a/sys/dev/em/if_em_fxhw.h
+++ b/sys/dev/em/if_em_fxhw.h
@@ -1,6 +1,6 @@
 /*******************************************************************************
 
-  Copyright (c) 2001 Intel Corporation 
+  Copyright (c) 2001-2002 Intel Corporation 
   All rights reserved. 
   
   Redistribution and use in source and binary forms of the Software, with or 
@@ -54,6 +54,7 @@ typedef enum {
     em_82542_rev2_1,
     em_82543,
     em_82544,
+    em_82540,
     em_num_macs
 } em_mac_type;
 
@@ -113,56 +114,36 @@ boolean_t em_init_hw(struct em_shared_adapter *shared);
 void em_init_rx_addrs(struct em_shared_adapter *shared);
 
 /* Filters (multicast, vlan, receive) */
-void em_mc_addr_list_update(struct em_shared_adapter *shared,
-                               uint8_t * mc_addr_list,
-                               uint32_t mc_addr_count,
-                               uint32_t pad);
-uint32_t em_hash_mc_addr(struct em_shared_adapter *shared,
-                            uint8_t * mc_addr);
-void em_mta_set(struct em_shared_adapter *shared,
-                   uint32_t hash_value);
-void em_rar_set(struct em_shared_adapter *shared,
-                   uint8_t * mc_addr,
-                   uint32_t rar_index);
-void em_write_vfta(struct em_shared_adapter *shared,
-                      uint32_t offset,
-                      uint32_t value);
+void em_mc_addr_list_update(struct em_shared_adapter *shared, uint8_t * mc_addr_list, uint32_t mc_addr_count, uint32_t pad);
+uint32_t em_hash_mc_addr(struct em_shared_adapter *shared, uint8_t * mc_addr);
+void em_mta_set(struct em_shared_adapter *shared, uint32_t hash_value);
+void em_rar_set(struct em_shared_adapter *shared, uint8_t * mc_addr, uint32_t rar_index);
+void em_write_vfta(struct em_shared_adapter *shared, uint32_t offset, uint32_t value);
 void em_clear_vfta(struct em_shared_adapter *shared);
 
 /* Link layer setup functions */
 boolean_t em_setup_fc_and_link(struct em_shared_adapter *shared);
-boolean_t em_setup_pcs_link(struct em_shared_adapter *shared,
-                               uint32_t dev_ctrl_reg);
+boolean_t em_setup_pcs_link(struct em_shared_adapter *shared, uint32_t dev_ctrl_reg);
 void em_config_fc_after_link_up(struct em_shared_adapter *shared);
 void em_check_for_link(struct em_shared_adapter *shared);
-void em_get_speed_and_duplex(struct em_shared_adapter *shared,
-                                uint16_t * speed,
-                                uint16_t * duplex);
+void em_get_speed_and_duplex(struct em_shared_adapter *shared, uint16_t * speed, uint16_t * duplex);
 
 /* EEPROM Functions */
-uint16_t em_read_eeprom(struct em_shared_adapter *shared,
-                           uint16_t reg);
+uint16_t em_read_eeprom(struct em_shared_adapter *shared, uint16_t reg);
 boolean_t em_validate_eeprom_checksum(struct em_shared_adapter *shared);
 void em_update_eeprom_checksum(struct em_shared_adapter *shared);
-boolean_t em_write_eeprom(struct em_shared_adapter *shared,
-                             uint16_t reg,
-                             uint16_t data);
+boolean_t em_write_eeprom(struct em_shared_adapter *shared, uint16_t reg, uint16_t data);
 
 /* Everything else */
 void em_clear_hw_cntrs(struct em_shared_adapter *shared);
-boolean_t em_read_part_num(struct em_shared_adapter *shared,
-                              uint32_t * part_num);
+boolean_t em_read_part_num(struct em_shared_adapter *shared, uint32_t * part_num);
 void em_led_on(struct em_shared_adapter *shared);
 void em_led_off(struct em_shared_adapter *shared);
 void em_get_bus_info(struct em_shared_adapter *shared);
-uint32_t em_tbi_adjust_stats(struct em_shared_adapter *shared,
-                                struct em_shared_stats *stats,
-                                uint32_t frame_len,
-                                uint8_t * mac_addr);
-void em_write_pci_cfg(struct em_shared_adapter *shared,
-                         uint32_t reg,
-                         uint16_t * value);
+uint32_t em_tbi_adjust_stats(struct em_shared_adapter *shared, struct em_shared_stats *stats, uint32_t frame_len, uint8_t * mac_addr);
+void em_write_pci_cfg(struct em_shared_adapter *shared, uint32_t reg, uint16_t * value);
 
+/* PCI Device IDs */
 #define E1000_DEV_ID_82542          0x1000
 #define E1000_DEV_ID_82543GC_FIBER  0x1001
 #define E1000_DEV_ID_82543GC_COPPER 0x1004
@@ -170,6 +151,8 @@ void em_write_pci_cfg(struct em_shared_adapter *shared,
 #define E1000_DEV_ID_82544EI_FIBER  0x1009
 #define E1000_DEV_ID_82544GC_COPPER 0x100C
 #define E1000_DEV_ID_82544GC_LOM    0x100D
+#define E1000_DEV_ID_82540EM        0x100E
+#define NUM_DEV_IDS 8
 
 #define NODE_ADDRESS_SIZE 6
 #define ETH_LENGTH_OF_ADDRESS 6
@@ -446,13 +429,15 @@ struct em_ffvt_entry {
 #define E1000_CTRL     0x00000  /* Device Control - RW */
 #define E1000_STATUS   0x00008  /* Device Status - RO */
 #define E1000_EECD     0x00010  /* EEPROM/Flash Control - RW */
-#define E1000_CTRLEXT  0x00018  /* Extended Device Control - RW */
+#define E1000_EERD     0x00014  /* EEPROM Read - RW */
+#define E1000_CTRL_EXT 0x00018  /* Extended Device Control - RW */
 #define E1000_MDIC     0x00020  /* MDI Control - RW */
 #define E1000_FCAL     0x00028  /* Flow Control Address Low - RW */
 #define E1000_FCAH     0x0002C  /* Flow Control Address High -RW */
 #define E1000_FCT      0x00030  /* Flow Control Type - RW */
 #define E1000_VET      0x00038  /* VLAN Ether Type - RW */
 #define E1000_ICR      0x000C0  /* Interrupt Cause Read - R/clr */
+#define E1000_ITR      0x000C4  /* Interrupt Throttling Rate - RW */
 #define E1000_ICS      0x000C8  /* Interrupt Cause Set - WO */
 #define E1000_IMS      0x000D0  /* Interrupt Mask Set - RW */
 #define E1000_IMC      0x000D8  /* Interrupt Mask Clear - WO */
@@ -463,6 +448,7 @@ struct em_ffvt_entry {
 #define E1000_TCTL     0x00400  /* TX Control - RW */
 #define E1000_TIPG     0x00410  /* TX Inter-packet gap -RW */
 #define E1000_TBT      0x00448  /* TX Burst Timer - RW */
+#define E1000_LEDCTL   0x00E00  /* LED Control - RW */
 #define E1000_PBA      0x01000  /* Packet Buffer Allocation - RW */
 #define E1000_FCRTL    0x02160  /* Flow Control Receive Threshold Low - RW */
 #define E1000_FCRTH    0x02168  /* Flow Control Receive Threshold High - RW */
@@ -473,6 +459,8 @@ struct em_ffvt_entry {
 #define E1000_RDT      0x02818  /* RX Descriptor Tail - RW */
 #define E1000_RDTR     0x02820  /* RX Delay Timer - RW */
 #define E1000_RXDCTL   0x02828  /* RX Descriptor Control - RW */
+#define E1000_RADV     0x0282C  /* RX Interrupt Absolute Delay Timer - RW */
+#define E1000_RSRPD    0x02C00  /* RX Small Packet Detect - RW */
 #define E1000_TXDMAC   0x03000  /* TX DMA Control - RW */
 #define E1000_TDBAL    0x03800  /* TX Descriptor Base Address Low - RW */
 #define E1000_TDBAH    0x03804  /* TX Descriptor Base Address High - RW */
@@ -481,6 +469,7 @@ struct em_ffvt_entry {
 #define E1000_TDT      0x03818  /* TX Descripotr Tail - RW */
 #define E1000_TIDV     0x03820  /* TX Interrupt Delay Value - RW */
 #define E1000_TXDCTL   0x03828  /* TX Descriptor Control - RW */
+#define E1000_TADV     0x0382C  /* TX Interrupt Absolute Delay Val - RW */
 #define E1000_TSPMT    0x03830  /* TCP Segmentation PAD & Min Threshold - RW */
 #define E1000_CRCERRS  0x04000  /* CRC Error Count - R/clr */
 #define E1000_ALGNERRC 0x04004  /* Alignment Error Count - R/clr */
@@ -521,6 +510,9 @@ struct em_ffvt_entry {
 #define E1000_RFC      0x040A8  /* RX Fragment Count - R/clr */
 #define E1000_ROC      0x040AC  /* RX Oversize Count - R/clr */
 #define E1000_RJC      0x040B0  /* RX Jabber Count - R/clr */
+#define E1000_MGTPRC   0x040B4  /* Management Packets RX Count - R/clr */
+#define E1000_MGTPDC   0x040B8  /* Management Packets Dropped Count - R/clr */
+#define E1000_MGTPTC   0x040BC  /* Management Packets TX Count - R/clr */
 #define E1000_TORL     0x040C0  /* Total Octets RX Low - R/clr */
 #define E1000_TORH     0x040C4  /* Total Octets RX High - R/clr */
 #define E1000_TOTL     0x040C8  /* Total Octets TX Low - R/clr */
@@ -544,8 +536,10 @@ struct em_ffvt_entry {
 #define E1000_WUC      0x05800  /* Wakeup Control - RW */
 #define E1000_WUFC     0x05808  /* Wakeup Filter Control - RW */
 #define E1000_WUS      0x05810  /* Wakeup Status - RO */
+#define E1000_MANC     0x05820  /* Management Control - RW */
 #define E1000_IPAV     0x05838  /* IP Address Valid - RW */
 #define E1000_IP4AT    0x05840  /* IPv4 Address Table - RW Array */
+#define E1000_IP6AT    0x05880  /* IPv6 Address Table - RW Array */
 #define E1000_WUPL     0x05900  /* Wakeup Packet Length - RW */
 #define E1000_WUPM     0x05A00  /* Wakeup Packet Memory - RO A */
 #define E1000_FFLT     0x05F00  /* Flexible Filter Length Table - RW Array */
@@ -561,7 +555,8 @@ struct em_ffvt_entry {
 #define E1000_82542_CTRL     E1000_CTRL
 #define E1000_82542_STATUS   E1000_STATUS
 #define E1000_82542_EECD     E1000_EECD
-#define E1000_82542_CTRLEXT  E1000_CTRLEXT
+#define E1000_82542_EERD     E1000_EERD
+#define E1000_82542_CTRL_EXT E1000_CTRL_EXT
 #define E1000_82542_MDIC     E1000_MDIC
 #define E1000_82542_FCAL     E1000_FCAL
 #define E1000_82542_FCAH     E1000_FCAH
@@ -569,6 +564,7 @@ struct em_ffvt_entry {
 #define E1000_82542_VET      E1000_VET
 #define E1000_82542_RA       0x00040
 #define E1000_82542_ICR      E1000_ICR
+#define E1000_82542_ITR      E1000_ITR
 #define E1000_82542_ICS      E1000_ICS
 #define E1000_82542_IMS      E1000_IMS
 #define E1000_82542_IMC      E1000_IMC
@@ -595,10 +591,14 @@ struct em_ffvt_entry {
 #define E1000_82542_TIDV     0x00440
 #define E1000_82542_TBT      E1000_TBT
 #define E1000_82542_VFTA     0x00600
+#define E1000_82542_LEDCTL   E1000_LEDCTL
 #define E1000_82542_PBA      E1000_PBA
 #define E1000_82542_RXDCTL   E1000_RXDCTL
+#define E1000_82542_RADV     E1000_RADV
+#define E1000_82542_RSRPD    E1000_RSRPD
 #define E1000_82542_TXDMAC   E1000_TXDMAC
 #define E1000_82542_TXDCTL   E1000_TXDCTL
+#define E1000_82542_TADV     E1000_TADV
 #define E1000_82542_TSPMT    E1000_TSPMT
 #define E1000_82542_CRCERRS  E1000_CRCERRS
 #define E1000_82542_ALGNERRC E1000_ALGNERRC
@@ -639,6 +639,9 @@ struct em_ffvt_entry {
 #define E1000_82542_RFC      E1000_RFC
 #define E1000_82542_ROC      E1000_ROC
 #define E1000_82542_RJC      E1000_RJC
+#define E1000_82542_MGTPRC   E1000_MGTPRC
+#define E1000_82542_MGTPDC   E1000_MGTPDC
+#define E1000_82542_MGTPTC   E1000_MGTPTC
 #define E1000_82542_TORL     E1000_TORL
 #define E1000_82542_TORH     E1000_TORH
 #define E1000_82542_TOTL     E1000_TOTL
@@ -659,8 +662,10 @@ struct em_ffvt_entry {
 #define E1000_82542_WUC      E1000_WUC
 #define E1000_82542_WUFC     E1000_WUFC
 #define E1000_82542_WUS      E1000_WUS
+#define E1000_82542_MANC     E1000_MANC
 #define E1000_82542_IPAV     E1000_IPAV
 #define E1000_82542_IP4AT    E1000_IP4AT
+#define E1000_82542_IP6AT    E1000_IP6AT
 #define E1000_82542_WUPL     E1000_WUPL
 #define E1000_82542_WUPM     E1000_WUPM
 #define E1000_82542_FFLT     E1000_FFLT
@@ -747,6 +752,7 @@ struct em_shared_adapter {
     uint32_t txcw_reg;
     uint32_t autoneg_failed;
     uint32_t max_frame_size;
+    uint32_t min_frame_size;
     uint32_t mc_filter_type;
     uint32_t num_mc_addrs;
     uint16_t autoneg_advertised;
@@ -754,6 +760,11 @@ struct em_shared_adapter {
     uint16_t fc_high_water;
     uint16_t fc_low_water;
     uint16_t fc_pause_time;
+    uint16_t device_id;
+    uint16_t vendor_id;
+    uint16_t subsystem_id;
+    uint16_t subsystem_vendor_id;
+    uint8_t revision_id;
     boolean_t disable_polarity_correction;
     boolean_t get_link_status;
     boolean_t tbi_compatibility_en;
@@ -762,7 +773,6 @@ struct em_shared_adapter {
     boolean_t fc_send_xon;
     boolean_t report_tx_early;
     boolean_t low_profile;
-    boolean_t large_eeprom;
     uint8_t autoneg;
     uint8_t mdix;
     uint8_t forced_speed_duplex;
@@ -772,7 +782,7 @@ struct em_shared_adapter {
 };
 
 
-#define E1000_EEPROM_SWDPIN0   0x00000001       /* SWDPIN 0 EEPROM Value */
+#define E1000_EEPROM_SWDPIN0   0x0001   /* SWDPIN 0 EEPROM Value */
 #define E1000_EEPROM_LED_LOGIC 0x0020   /* Led Logic Word */
 
 /* Register Bit Masks */
@@ -811,6 +821,9 @@ struct em_shared_adapter {
 /* Device Status */
 #define E1000_STATUS_FD         0x00000001      /* Full duplex.0=half,1=full */
 #define E1000_STATUS_LU         0x00000002      /* Link up.0=no,1=link */
+#define E1000_STATUS_FUNC_MASK  0x0000000C      /* PCI Function Mask */
+#define E1000_STATUS_FUNC_0     0x00000000      /* Function 0 */
+#define E1000_STATUS_FUNC_1     0x00000004      /* Function 1 */
 #define E1000_STATUS_TXOFF      0x00000010      /* transmission paused */
 #define E1000_STATUS_TBIMODE    0x00000020      /* TBI mode */
 #define E1000_STATUS_SPEED_MASK 0x000000C0
@@ -839,6 +852,17 @@ struct em_shared_adapter {
 #define E1000_EECD_FWE_EN    0x00000020 /* Enable FLASH writes */
 #define E1000_EECD_FWE_SHIFT 4
 #define E1000_EECD_SIZE      0x00000200 /* EEPROM Size (0=64 word 1=256 word) */
+#define E1000_EECD_REQ       0x00000040 /* EEPROM Access Request */
+#define E1000_EECD_GNT       0x00000080 /* EEPROM Access Grant */
+#define E1000_EECD_PRES      0x00000100 /* EEPROM Present */
+
+/* EEPROM Read */
+#define E1000_EERD_START      0x00000001 /* Start Read */
+#define E1000_EERD_DONE       0x00000010 /* Read Done */
+#define E1000_EERD_ADDR_SHIFT 8
+#define E1000_EERD_ADDR_MASK  0x0000FF00 /* Read Address */
+#define E1000_EERD_DATA_SHIFT 16
+#define E1000_EERD_DATA_MASK  0xFFFF0000 /* Read Data */
 
 /* Extended Device Control */
 #define E1000_CTRL_EXT_GPI0_EN   0x00000001 /* Maps SDP4 to GPI0 */ 
@@ -859,6 +883,14 @@ struct em_shared_adapter {
 #define E1000_CTRL_EXT_EE_RST    0x00002000 /* Reinitialize from EEPROM */
 #define E1000_CTRL_EXT_IPS       0x00004000 /* Invert Power State */
 #define E1000_CTRL_EXT_SPD_BYPS  0x00008000 /* Speed Select Bypass */
+#define E1000_CTRL_EXT_LINK_MODE_MASK 0x00C00000
+#define E1000_CTRL_EXT_LINK_MODE_GMII 0x00000000
+#define E1000_CTRL_EXT_LINK_MODE_TBI  0x00C00000
+#define E1000_CTRL_EXT_WR_WMARK_MASK  0x03000000
+#define E1000_CTRL_EXT_WR_WMARK_256   0x00000000
+#define E1000_CTRL_EXT_WR_WMARK_320   0x01000000
+#define E1000_CTRL_EXT_WR_WMARK_384   0x02000000
+#define E1000_CTRL_EXT_WR_WMARK_448   0x03000000
 
 /* MDI Control */
 #define E1000_MDIC_DATA_MASK 0x0000FFFF
@@ -872,6 +904,40 @@ struct em_shared_adapter {
 #define E1000_MDIC_INT_EN    0x20000000
 #define E1000_MDIC_ERROR     0x40000000
 
+/* LED Control */
+#define E1000_LEDCTL_LED0_MODE_MASK  0x0000000F
+#define E1000_LEDCTL_LED0_MODE_SHIFT 0
+#define E1000_LEDCTL_LED0_IVRT       0x00000040
+#define E1000_LEDCTL_LED0_BLINK      0x00000080
+#define E1000_LEDCTL_LED1_MODE_MASK  0x00000F00
+#define E1000_LEDCTL_LED1_MODE_SHIFT 8
+#define E1000_LEDCTL_LED1_IVRT       0x00004000
+#define E1000_LEDCTL_LED1_BLINK      0x00008000
+#define E1000_LEDCTL_LED2_MODE_MASK  0x000F0000
+#define E1000_LEDCTL_LED2_MODE_SHIFT 16
+#define E1000_LEDCTL_LED2_IVRT       0x00400000
+#define E1000_LEDCTL_LED2_BLINK      0x00800000
+#define E1000_LEDCTL_LED3_MODE_MASK  0x0F000000
+#define E1000_LEDCTL_LED3_MODE_SHIFT 24
+#define E1000_LEDCTL_LED3_IVRT       0x40000000
+#define E1000_LEDCTL_LED3_BLINK      0x80000000
+
+#define E1000_LEDCTL_MODE_LINK_10_1000  0x0
+#define E1000_LEDCTL_MODE_LINK_100_1000 0x1
+#define E1000_LEDCTL_MODE_LINK_UP       0x2
+#define E1000_LEDCTL_MODE_ACTIVITY      0x3
+#define E1000_LEDCTL_MODE_LINK_ACTIVITY 0x4
+#define E1000_LEDCTL_MODE_LINK_10       0x5
+#define E1000_LEDCTL_MODE_LINK_100      0x6
+#define E1000_LEDCTL_MODE_LINK_1000     0x7
+#define E1000_LEDCTL_MODE_PCIX_MODE     0x8
+#define E1000_LEDCTL_MODE_FULL_DUPLEX   0x9
+#define E1000_LEDCTL_MODE_COLLISION     0xA
+#define E1000_LEDCTL_MODE_BUS_SPEED     0xB
+#define E1000_LEDCTL_MODE_BUS_SIZE      0xC
+#define E1000_LEDCTL_MODE_PAUSED        0xD
+#define E1000_LEDCTL_MODE_LED_ON        0xE
+#define E1000_LEDCTL_MODE_LED_OFF       0xF
 
 /* Receive Address */
 #define E1000_RAH_AV  0x80000000        /* Receive descriptor valid */
@@ -890,6 +956,8 @@ struct em_shared_adapter {
 #define E1000_ICR_GPI_EN1 0x00001000    /* GP Int 1 */
 #define E1000_ICR_GPI_EN2 0x00002000    /* GP Int 2 */
 #define E1000_ICR_GPI_EN3 0x00004000    /* GP Int 3 */
+#define E1000_ICR_TXD_LOW 0x00008000
+#define E1000_ICR_SRPD    0x00010000
 
 /* Interrupt Cause Set */
 #define E1000_ICS_TXDW    E1000_ICR_TXDW        /* Transmit desc written back */
@@ -905,6 +973,8 @@ struct em_shared_adapter {
 #define E1000_ICS_GPI_EN1 E1000_ICR_GPI_EN1     /* GP Int 1 */
 #define E1000_ICS_GPI_EN2 E1000_ICR_GPI_EN2     /* GP Int 2 */
 #define E1000_ICS_GPI_EN3 E1000_ICR_GPI_EN3     /* GP Int 3 */
+#define E1000_ICS_TXD_LOW E1000_ICR_TXD_LOW
+#define E1000_ICS_SRPD    E1000_ICR_SRPD
 
 /* Interrupt Mask Set */
 #define E1000_IMS_TXDW    E1000_ICR_TXDW        /* Transmit desc written back */
@@ -920,6 +990,8 @@ struct em_shared_adapter {
 #define E1000_IMS_GPI_EN1 E1000_ICR_GPI_EN1     /* GP Int 1 */
 #define E1000_IMS_GPI_EN2 E1000_ICR_GPI_EN2     /* GP Int 2 */
 #define E1000_IMS_GPI_EN3 E1000_ICR_GPI_EN3     /* GP Int 3 */
+#define E1000_IMS_TXD_LOW E1000_ICR_TXD_LOW
+#define E1000_IMS_SRPD    E1000_ICR_SRPD
 
 /* Interrupt Mask Clear */
 #define E1000_IMC_TXDW    E1000_ICR_TXDW        /* Transmit desc written back */
@@ -935,6 +1007,8 @@ struct em_shared_adapter {
 #define E1000_IMC_GPI_EN1 E1000_ICR_GPI_EN1     /* GP Int 1 */
 #define E1000_IMC_GPI_EN2 E1000_ICR_GPI_EN2     /* GP Int 2 */
 #define E1000_IMC_GPI_EN3 E1000_ICR_GPI_EN3     /* GP Int 3 */
+#define E1000_IMC_TXD_LOW E1000_ICR_TXD_LOW
+#define E1000_IMC_SRPD    E1000_ICR_SRPD
 
 /* Receive Control */
 #define E1000_RCTL_RST          0x00000001      /* Software reset */
@@ -997,6 +1071,7 @@ struct em_shared_adapter {
 #define E1000_TXDCTL_HTHRESH 0x0000FF00 /* TXDCTL Host Threshold */
 #define E1000_TXDCTL_WTHRESH 0x00FF0000 /* TXDCTL Writeback Threshold */
 #define E1000_TXDCTL_GRAN    0x01000000 /* TXDCTL Granularity */
+#define E1000_TXDCTL_LWTHRESH 0xFE000000 /* TXDCTL Low Threshold */
 
 /* Transmit Configuration Word */
 #define E1000_TXCW_FD         0x00000020        /* TXCW full duplex */
@@ -1035,6 +1110,7 @@ struct em_shared_adapter {
 #define E1000_RXCSUM_PCSS_MASK 0x000000FF   /* Packet Checksum Start */
 #define E1000_RXCSUM_IPOFL     0x00000100   /* IPv4 checksum offload */
 #define E1000_RXCSUM_TUOFL     0x00000200   /* TCP / UDP checksum offload */
+#define E1000_RXCSUM_IPV6OFL   0x00000400   /* IPv6 checksum offload */
 
 /* Definitions for power management and wakeup registers */
 /* Wake Up Control */
@@ -1051,6 +1127,7 @@ struct em_shared_adapter {
 #define E1000_WUFC_BC   0x00000010 /* Broadcast Wakeup Enable */
 #define E1000_WUFC_ARP  0x00000020 /* ARP Request Packet Wakeup Enable */
 #define E1000_WUFC_IPV4 0x00000040 /* Directed IPv4 Packet Wakeup Enable */
+#define E1000_WUFC_IPV6 0x00000080 /* Directed IPv6 Packet Wakeup Enable */
 #define E1000_WUFC_FLX0 0x00010000 /* Flexible Filter 0 Enable */
 #define E1000_WUFC_FLX1 0x00020000 /* Flexible Filter 1 Enable */
 #define E1000_WUFC_FLX2 0x00040000 /* Flexible Filter 2 Enable */
@@ -1067,12 +1144,37 @@ struct em_shared_adapter {
 #define E1000_WUS_BC   0x00000010 /* Broadcast Received */
 #define E1000_WUS_ARP  0x00000020 /* ARP Request Packet Received */
 #define E1000_WUS_IPV4 0x00000040 /* Directed IPv4 Packet Wakeup Received */
+#define E1000_WUS_IPV6 0x00000080 /* Directed IPv6 Packet Wakeup Received */
 #define E1000_WUS_FLX0 0x00010000 /* Flexible Filter 0 Match */
 #define E1000_WUS_FLX1 0x00020000 /* Flexible Filter 1 Match */
 #define E1000_WUS_FLX2 0x00040000 /* Flexible Filter 2 Match */
 #define E1000_WUS_FLX3 0x00080000 /* Flexible Filter 3 Match */
 #define E1000_WUS_FLX_FILTERS 0x000F0000 /* Mask for the 4 flexible filters */
 
+/* Management Control */
+#define E1000_MANC_SMBUS_EN      0x00000001 /* SMBus Enabled - RO */
+#define E1000_MANC_ASF_EN        0x00000002 /* ASF Enabled - RO */
+#define E1000_MANC_R_ON_FORCE    0x00000004 /* Reset on Force TCO - RO */
+#define E1000_MANC_RMCP_EN       0x00000100 /* Enable RCMP 026Fh Filtering */
+#define E1000_MANC_0298_EN       0x00000200 /* Enable RCMP 0298h Filtering */
+#define E1000_MANC_IPV4_EN       0x00000400 /* Enable IPv4 */
+#define E1000_MANC_IPV6_EN       0x00000800 /* Enable IPv6 */
+#define E1000_MANC_SNAP_EN       0x00001000 /* Accept LLC/SNAP */
+#define E1000_MANC_ARP_EN        0x00002000 /* Enable ARP Request Filtering */
+#define E1000_MANC_NEIGHBOR_EN   0x00004000 /* Enable Neighbor Discovery 
+                                             * Filtering */
+#define E1000_MANC_TCO_RESET     0x00010000 /* TCO Reset Occurred */
+#define E1000_MANC_RCV_TCO_EN    0x00020000 /* Receive TCO Packets Enabled */
+#define E1000_MANC_REPORT_STATUS 0x00040000 /* Status Reporting Enabled */
+#define E1000_MANC_SMB_REQ       0x01000000 /* SMBus Request */
+#define E1000_MANC_SMB_GNT       0x02000000 /* SMBus Grant */
+#define E1000_MANC_SMB_CLK_IN    0x04000000 /* SMBus Clock In */
+#define E1000_MANC_SMB_DATA_IN   0x08000000 /* SMBus Data In */
+#define E1000_MANC_SMB_DATA_OUT  0x10000000 /* SMBus Data Out */
+#define E1000_MANC_SMB_CLK_OUT   0x20000000 /* SMBus Clock Out */
+
+#define E1000_MANC_SMB_DATA_OUT_SHIFT  28 /* SMBus Data Out Shift */
+#define E1000_MANC_SMB_CLK_OUT_SHIFT   29 /* SMBus Clock Out Shift */
 
 /* Wake Up Packet Length */
 #define E1000_WUPL_LENGTH_MASK 0x0FFF   /* Only the lower 12 bits are valid */
@@ -1130,7 +1232,7 @@ struct em_shared_adapter {
 
 /* Default values for the transmit IPG register */
 #define DEFAULT_82542_TIPG_IPGT        10
-#define DEFAULT_82543_TIPG_IPGT_FIBER  6
+#define DEFAULT_82543_TIPG_IPGT_FIBER  9
 #define DEFAULT_82543_TIPG_IPGT_COPPER 8
 
 #define E1000_TIPG_IPGT_MASK  0x000003FF
@@ -1202,23 +1304,15 @@ struct em_shared_adapter {
 
 /* TBI_ACCEPT macro definition:
  *
- * If Tbi Compatibility mode is turned-on, then we should accept frames with
- * receive errors if and only if:
- *      1) errors is equal to the CRC error bit.
- *      2) The last byte is a Carrier extension (0x0F).
- *      3) The frame length (as reported by Hardware) is greater than 64 (60
- *         if a VLAN tag was stripped from the frame.
- *      4) "    "     "      "   "       "   "        <= max_frame_size+1.
- *
  * This macro requires:
  *      adapter = a pointer to struct em_shared_adapter 
- *      special = the 16 bit special field of the RX descriptor with EOP set
+ *      status = the 8 bit status field of the RX descriptor with EOP set
  *      error = the 8 bit error field of the RX descriptor with EOP set
  *      length = the sum of all the length fields of the RX descriptors that
  *               make up the current frame
  *      last_byte = the last byte of the frame DMAed by the hardware
  *      max_frame_length = the maximum frame length we want to accept.
- *                         THIS INCLUDES THE 4 BYTE ETHERNET CRC!
+ *      min_frame_length = the minimum frame length we want to accept.
  *
  * This macro is a conditional that should be used in the interrupt 
  * handler's Rx processing routine when RxErrors have been detected.
@@ -1235,15 +1329,15 @@ struct em_shared_adapter {
  *  ...
  */
 
-#define TBI_ACCEPT(adapter, special, errors, length, last_byte) \
+#define TBI_ACCEPT(adapter, status, errors, length, last_byte) \
     ((adapter)->tbi_compatibility_on && \
      (((errors) & E1000_RXD_ERR_FRAME_ERR_MASK) == E1000_RXD_ERR_CE) && \
      ((last_byte) == CARRIER_EXTENSION) && \
-     ((special == 0x0000) ? \
-         ((length <= ((adapter)->max_frame_size + 1)) && \
-          (length > 64)) : \
-         ((length <= ((adapter)->max_frame_size - 3)) && \
-          (length > 60))))
+     (((status) & E1000_RXD_STAT_VP) ? \
+          (((length) > ((adapter)->min_frame_size - VLAN_TAG_SIZE)) && \
+           ((length) <= ((adapter)->max_frame_size + 1))) : \
+          (((length) > (adapter)->min_frame_size) && \
+           ((length) <= ((adapter)->max_frame_size + VLAN_TAG_SIZE + 1)))))
 
 
 #endif /* _EM_MAC_H_ */
diff --git a/sys/dev/em/if_em_osdep.h b/sys/dev/em/if_em_osdep.h
index 9d4b923..55c6da1 100644
--- a/sys/dev/em/if_em_osdep.h
+++ b/sys/dev/em/if_em_osdep.h
@@ -1,6 +1,6 @@
 /**************************************************************************
 
-Copyright (c) 2001 Intel Corporation
+Copyright (c) 2001-2002 Intel Corporation
 All rights reserved.
 
 Redistribution and use in source and binary forms of the Software, with or
diff --git a/sys/dev/em/if_em_phy.c b/sys/dev/em/if_em_phy.c
index d359b28..76ffaae 100644
--- a/sys/dev/em/if_em_phy.c
+++ b/sys/dev/em/if_em_phy.c
@@ -1,6 +1,6 @@
 /*******************************************************************************
 
-  Copyright (c) 2001 Intel Corporation 
+  Copyright (c) 2001-2002 Intel Corporation 
   All rights reserved. 
   
   Redistribution and use in source and binary forms of the Software, with or 
@@ -234,7 +234,7 @@ em_phy_force_speed_duplex(struct em_shared_adapter *shared)
     /* Read the MII Control Register. */
     mii_ctrl_reg = em_read_phy_reg(shared, PHY_CTRL);
 
-    /* We need to disable Autoneg in order to force link and duplex. */
+    /* We need to disable autoneg in order to force link and duplex. */
 
     mii_ctrl_reg &= ~MII_CR_AUTO_NEG_EN;
 
@@ -337,11 +337,11 @@ em_phy_force_speed_duplex(struct em_shared_adapter *shared)
      * the default.
      */
     if(shared->wait_autoneg_complete) {
-        /* We will wait for AutoNeg to complete. */
+        /* We will wait for autoneg to complete. */
         DEBUGOUT("Waiting for forced speed/duplex link.\n");
         mii_status_reg = 0;
 
-        /* We will wait for AutoNeg to complete or 4.5 seconds to expire. */
+        /* We will wait for autoneg to complete or 4.5 seconds to expire. */
         for(i = PHY_FORCE_TIME; i > 0; i--) {
             /* Read the MII Status Register and wait for Auto-Neg
              * Complete bit to be set.
@@ -414,8 +414,6 @@ em_read_phy_reg(struct em_shared_adapter *shared,
     uint32_t data = 0;
     uint32_t command = 0;
 
-    DEBUGFUNC("em_read_phy_reg");
-
     ASSERT(reg_addr <= MAX_PHY_REG_ADDRESS);
 
     if(shared->mac_type > em_82543) {
@@ -428,7 +426,6 @@ em_read_phy_reg(struct em_shared_adapter *shared,
                    (shared->phy_addr << E1000_MDIC_PHY_SHIFT) | 
                    (E1000_MDIC_OP_READ));
 
-        DEBUGOUT1("Writing 0x%X to MDIC\n", command);
         E1000_WRITE_REG(shared, MDIC, command);
 
         /* Check every 10 usec to see if the read completed.  The read
@@ -440,7 +437,6 @@ em_read_phy_reg(struct em_shared_adapter *shared,
 
             data = E1000_READ_REG(shared, MDIC);
 
-            DEBUGOUT1("Read 0x%X from MDIC\n", data);
             if(data & E1000_MDIC_READY)
                 break;
         }
@@ -587,30 +583,30 @@ em_phy_hw_reset(struct em_shared_adapter *shared)
         /* Read the Extended Device Control Register, assert the
          * PHY_RESET_DIR bit.  Then clock it out to the PHY.
          */
-        ctrl_ext_reg = E1000_READ_REG(shared, CTRLEXT);
+        ctrl_ext_reg = E1000_READ_REG(shared, CTRL_EXT);
 
         ctrl_ext_reg |= E1000_CTRL_PHY_RESET_DIR4;
 
-        E1000_WRITE_REG(shared, CTRLEXT, ctrl_ext_reg);
+        E1000_WRITE_REG(shared, CTRL_EXT, ctrl_ext_reg);
 
         msec_delay(20);
 
         /* Set the reset bit in the device control register and clock
          * it out to the PHY.
          */
-        ctrl_ext_reg = E1000_READ_REG(shared, CTRLEXT);
+        ctrl_ext_reg = E1000_READ_REG(shared, CTRL_EXT);
 
         ctrl_ext_reg &= ~E1000_CTRL_PHY_RESET4;
 
-        E1000_WRITE_REG(shared, CTRLEXT, ctrl_ext_reg);
+        E1000_WRITE_REG(shared, CTRL_EXT, ctrl_ext_reg);
 
         msec_delay(20);
 
-        ctrl_ext_reg = E1000_READ_REG(shared, CTRLEXT);
+        ctrl_ext_reg = E1000_READ_REG(shared, CTRL_EXT);
 
         ctrl_ext_reg |= E1000_CTRL_PHY_RESET4;
 
-        E1000_WRITE_REG(shared, CTRLEXT, ctrl_ext_reg);
+        E1000_WRITE_REG(shared, CTRL_EXT, ctrl_ext_reg);
 
         msec_delay(20);
     }
@@ -696,7 +692,7 @@ em_phy_setup(struct em_shared_adapter *shared,
      * on the PHY to take it out of reset.
      */
     if(shared->mac_type >= em_82544) {
-        ctrl_reg |= (E1000_CTRL_ASDE | E1000_CTRL_SLU);
+        ctrl_reg |= E1000_CTRL_SLU;
         E1000_WRITE_REG(shared, CTRL, ctrl_reg);
     } else {
         ctrl_reg |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX | E1000_CTRL_SLU);
@@ -768,7 +764,7 @@ em_phy_setup(struct em_shared_adapter *shared,
     /* Read the MII Auto-Neg Advertisement Register (Address 4). */
     mii_autoneg_adv_reg = em_read_phy_reg(shared, PHY_AUTONEG_ADV);
 
-    /* Shift left to put 10T-Half bit in bit 0
+    /* Shift right to put 10T-Half bit in bit 0
      * Isolate the four bits for 100/10 Full/Half.
      */ 
     autoneg_hw_setting = (mii_autoneg_adv_reg >> 5) & 0xF;
@@ -892,13 +888,11 @@ em_phy_setup(struct em_shared_adapter *shared,
      *      depending on value parsed from forced_speed_duplex.
      */
 
-    /* Is AutoNeg enabled?  This is enabled by default or by software
-     * override.  If so,
-     * call PhySetupAutoNegAdvertisement routine to parse the
-     * autoneg_advertised and fc options.
-     * If AutoNeg is NOT enabled, then the user should have provided
-     * a Speed/Duplex override.  If so, then call the
-     * PhyForceSpeedAndDuplex to parse and set this up.  Otherwise,
+    /* Is autoneg enabled?  This is enabled by default or by software override.
+     * If so, call em_phy_setup_autoneg routine to parse the
+     * autoneg_advertised and fc options. If autoneg is NOT enabled, then the
+     * user should have provided a speed/duplex override.  If so, then call
+     * em_phy_force_speed_duplex to parse and set this up.  Otherwise,
      * we are in an error situation and need to bail.
      */
     if(shared->autoneg) {
@@ -1057,8 +1051,7 @@ em_phy_setup_autoneg(struct em_shared_adapter *shared)
      * setup the PHY advertisement registers accordingly.  If
      * auto-negotiation is enabled, then software will have to set the
      * "PAUSE" bits to the correct value in the Auto-Negotiation
-     * Advertisement Register (PHY_AUTONEG_ADVERTISEMENT) and re-start
-     * auto-negotiation.
+     * Advertisement Register (PHY_AUTONEG_ADV) and re-start auto-negotiation.
      *
      * The possible values of the "fc" parameter are:
      *      0:  Flow control is completely disabled
@@ -1291,7 +1284,7 @@ em_display_mii(struct em_shared_adapter *shared)
 
     DEBUGFUNC("em_display_mii");
 
-    DEBUGOUT1("adapter Base Address = %p\n", shared->hw_addr);
+    DEBUGOUT1("adapter Base Address = %x\n", shared->hw_addr);
 
     /* This will read each PHY Reg address and display its contents. */
 
@@ -1389,7 +1382,8 @@ em_detect_gig_phy(struct em_shared_adapter *shared)
 
     if(shared->phy_id == M88E1000_12_PHY_ID ||
        shared->phy_id == M88E1000_14_PHY_ID ||
-       shared->phy_id == M88E1000_I_PHY_ID) {
+       shared->phy_id == M88E1000_I_PHY_ID  ||
+       shared->phy_id == M88E1011_I_PHY_ID) {
 
         DEBUGOUT2("phy_id 0x%x detected at address 0x%x\n",
                   shared->phy_id, shared->phy_addr);
@@ -1428,11 +1422,11 @@ em_wait_autoneg(struct em_shared_adapter *shared)
 
     DEBUGFUNC("em_wait_autoneg");
 
-    /* We will wait for AutoNeg to complete. */
+    /* We will wait for autoneg to complete. */
     DEBUGOUT("Waiting for Auto-Neg to complete.\n");
     mii_status_reg = 0;
 
-    /* We will wait for AutoNeg to complete or 4.5 seconds to expire. */
+    /* We will wait for autoneg to complete or 4.5 seconds to expire. */
 
     for(i = PHY_AUTO_NEG_TIME; i > 0; i--) {
         /* Read the MII Status Register and wait for Auto-Neg
@@ -1462,7 +1456,7 @@ boolean_t
 em_phy_get_info(struct em_shared_adapter *shared,
                    struct em_phy_info *phy_status_info)
 {
-    uint16_t phy_mii_shatus_reg;
+    uint16_t phy_mii_status_reg;
     uint16_t phy_specific_ctrl_reg;
     uint16_t phy_specific_status_reg;
     uint16_t phy_specific_ext_ctrl_reg;
@@ -1485,9 +1479,9 @@ em_phy_get_info(struct em_shared_adapter *shared,
     /* PHY info only valid for LINK UP.  Read MII status reg 
      * back-to-back to get link status.
      */
-    phy_mii_shatus_reg = em_read_phy_reg(shared, PHY_STATUS);
-    phy_mii_shatus_reg = em_read_phy_reg(shared, PHY_STATUS);
-    if((phy_mii_shatus_reg & MII_SR_LINK_STATUS) != MII_SR_LINK_STATUS)
+    phy_mii_status_reg = em_read_phy_reg(shared, PHY_STATUS);
+    phy_mii_status_reg = em_read_phy_reg(shared, PHY_STATUS);
+    if((phy_mii_status_reg & MII_SR_LINK_STATUS) != MII_SR_LINK_STATUS)
         return FALSE;
 
     /* Read various PHY registers to get the PHY info. */
diff --git a/sys/dev/em/if_em_phy.h b/sys/dev/em/if_em_phy.h
index f2cc25f..b1cc365 100644
--- a/sys/dev/em/if_em_phy.h
+++ b/sys/dev/em/if_em_phy.h
@@ -1,6 +1,6 @@
 /*******************************************************************************
 
-  Copyright (c) 2001 Intel Corporation 
+  Copyright (c) 2001-2002 Intel Corporation 
   All rights reserved. 
   
   Redistribution and use in source and binary forms of the Software, with or 
@@ -102,27 +102,26 @@ struct em_phy_info {
     em_1000t_rx_status remote_rx;
 };
 
+struct em_phy_stats {
+    uint32_t idle_errors;
+    uint32_t receive_errors;
+};
+
 /* Function Prototypes */
-uint16_t em_read_phy_reg(struct em_shared_adapter *shared,
-                            uint32_t reg_addr);
-void em_write_phy_reg(struct em_shared_adapter *shared,
-                         uint32_t reg_addr,
-                         uint16_t data);
+uint16_t em_read_phy_reg(struct em_shared_adapter *shared, uint32_t reg_addr);
+void em_write_phy_reg(struct em_shared_adapter *shared, uint32_t reg_addr, uint16_t data);
 void em_phy_hw_reset(struct em_shared_adapter *shared);
 boolean_t em_phy_reset(struct em_shared_adapter *shared);
-boolean_t em_phy_setup(struct em_shared_adapter *shared,
-                          uint32_t ctrl_reg);
+boolean_t em_phy_setup(struct em_shared_adapter *shared, uint32_t ctrl_reg);
 boolean_t em_phy_setup_autoneg(struct em_shared_adapter *shared);
-void em_config_mac_to_phy(struct em_shared_adapter *shared,
-                             uint16_t mii_reg);
+void em_config_mac_to_phy(struct em_shared_adapter *shared, uint16_t mii_reg);
 void em_config_collision_dist(struct em_shared_adapter *shared);
 void em_display_mii(struct em_shared_adapter *shared);
 boolean_t em_detect_gig_phy(struct em_shared_adapter *shared);
 void em_phy_reset_dsp(struct em_shared_adapter *shared);
 boolean_t em_wait_autoneg(struct em_shared_adapter *shared);
-boolean_t em_phy_get_info(struct em_shared_adapter *shared,
-                             struct em_phy_info *phy_status_info);
-boolean_t em_validate_mdi_setting(struct em_shared_adapter * shared);
+boolean_t em_phy_get_info(struct em_shared_adapter *shared, struct em_phy_info *phy_status_info);
+boolean_t em_validate_mdi_setting(struct em_shared_adapter *shared);
 
 /* Bit definitions for the Management Data IO (MDIO) and Management Data
  * Clock (MDC) pins in the Device Control Register.
@@ -357,6 +356,7 @@ boolean_t em_validate_mdi_setting(struct em_shared_adapter * shared);
 #define M88E1000_12_PHY_ID 0x01410C50
 #define M88E1000_14_PHY_ID 0x01410C40
 #define M88E1000_I_PHY_ID  0x01410C30
+#define M88E1011_I_PHY_ID  0x01410C20
 
 /* Miscellaneous PHY bit definitions. */
 #define PHY_PREAMBLE        0xFFFFFFFF