sys/dev/em/if_em.c

   1 /**************************************************************************
   2
   3 Copyright (c) 2001-2005, Intel Corporation
   4 All rights reserved.
   5
   6 Redistribution and use in source and binary forms, with or without
   7 modification, are permitted provided that the following conditions are met:
   8
   9  1. Redistributions of source code must retain the above copyright notice,
  10     this list of conditions and the following disclaimer.
  11
  12  2. Redistributions in binary form must reproduce the above copyright
  13     notice, this list of conditions and the following disclaimer in the
  14     documentation and/or other materials provided with the distribution.
  15
  16  3. Neither the name of the Intel Corporation nor the names of its
  17     contributors may be used to endorse or promote products derived from
  18     this software without specific prior written permission.
  19
  20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30 POSSIBILITY OF SUCH DAMAGE.
  31
  32 ***************************************************************************/
  33
  34 /*$FreeBSD$*/
  35
  36 #include <dev/em/if_em.h>
  37
  38 /*********************************************************************
  39  *  Set this to one to display debug statistics
  40  *********************************************************************/
  41 int             em_display_debug_stats = 0;
  42
  43 /*********************************************************************
  44  *  Linked list of board private structures for all NICs found
  45  *********************************************************************/
  46
  47 struct adapter *em_adapter_list = NULL;
  48
  49
  50 /*********************************************************************
  51  *  Driver version
  52  *********************************************************************/
  53
  54 char em_driver_version[] = "2.1.7";
  55
  56
  57 /*********************************************************************
  58  *  PCI Device ID Table
  59  *
  60  *  Used by probe to select devices to load on
  61  *  Last field stores an index into em_strings
  62  *  Last entry must be all 0s
  63  *
  64  *  { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
  65  *********************************************************************/
  66
  67 static em_vendor_info_t em_vendor_info_array[] =
  68 {
  69         /* Intel(R) PRO/1000 Network Connection */
  70         { 0x8086, E1000_DEV_ID_82540EM,             PCI_ANY_ID, PCI_ANY_ID, 0},
  71         { 0x8086, E1000_DEV_ID_82540EM_LOM,         PCI_ANY_ID, PCI_ANY_ID, 0},
  72         { 0x8086, E1000_DEV_ID_82540EP,             PCI_ANY_ID, PCI_ANY_ID, 0},
  73         { 0x8086, E1000_DEV_ID_82540EP_LOM,         PCI_ANY_ID, PCI_ANY_ID, 0},
  74         { 0x8086, E1000_DEV_ID_82540EP_LP,          PCI_ANY_ID, PCI_ANY_ID, 0},
  75
  76         { 0x8086, E1000_DEV_ID_82541EI,             PCI_ANY_ID, PCI_ANY_ID, 0},
  77         { 0x8086, E1000_DEV_ID_82541ER,             PCI_ANY_ID, PCI_ANY_ID, 0},
  78         { 0x8086, E1000_DEV_ID_82541ER_LOM,             PCI_ANY_ID, PCI_ANY_ID, 0},
  79         { 0x8086, E1000_DEV_ID_82541EI_MOBILE,      PCI_ANY_ID, PCI_ANY_ID, 0},
  80         { 0x8086, E1000_DEV_ID_82541GI,             PCI_ANY_ID, PCI_ANY_ID, 0},
  81         { 0x8086, E1000_DEV_ID_82541GI_LF,          PCI_ANY_ID, PCI_ANY_ID, 0},
  82         { 0x8086, E1000_DEV_ID_82541GI_MOBILE,      PCI_ANY_ID, PCI_ANY_ID, 0},
  83
  84         { 0x8086, E1000_DEV_ID_82542,               PCI_ANY_ID, PCI_ANY_ID, 0},
  85
  86         { 0x8086, E1000_DEV_ID_82543GC_FIBER,       PCI_ANY_ID, PCI_ANY_ID, 0},
  87         { 0x8086, E1000_DEV_ID_82543GC_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
  88
  89         { 0x8086, E1000_DEV_ID_82544EI_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
  90         { 0x8086, E1000_DEV_ID_82544EI_FIBER,       PCI_ANY_ID, PCI_ANY_ID, 0},
  91         { 0x8086, E1000_DEV_ID_82544GC_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
  92         { 0x8086, E1000_DEV_ID_82544GC_LOM,         PCI_ANY_ID, PCI_ANY_ID, 0},
  93
  94         { 0x8086, E1000_DEV_ID_82545EM_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
  95         { 0x8086, E1000_DEV_ID_82545EM_FIBER,       PCI_ANY_ID, PCI_ANY_ID, 0},
  96         { 0x8086, E1000_DEV_ID_82545GM_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
  97         { 0x8086, E1000_DEV_ID_82545GM_FIBER,       PCI_ANY_ID, PCI_ANY_ID, 0},
  98         { 0x8086, E1000_DEV_ID_82545GM_SERDES,      PCI_ANY_ID, PCI_ANY_ID, 0},
  99
 100         { 0x8086, E1000_DEV_ID_82546EB_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
 101         { 0x8086, E1000_DEV_ID_82546EB_FIBER,       PCI_ANY_ID, PCI_ANY_ID, 0},
 102         { 0x8086, E1000_DEV_ID_82546EB_QUAD_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0},
 103         { 0x8086, E1000_DEV_ID_82546GB_COPPER,      PCI_ANY_ID, PCI_ANY_ID, 0},
 104         { 0x8086, E1000_DEV_ID_82546GB_FIBER,       PCI_ANY_ID, PCI_ANY_ID, 0},
 105         { 0x8086, E1000_DEV_ID_82546GB_SERDES,      PCI_ANY_ID, PCI_ANY_ID, 0},
 106         { 0x8086, E1000_DEV_ID_82546GB_PCIE,        PCI_ANY_ID, PCI_ANY_ID, 0},
 107         { 0x8086, E1000_DEV_ID_82546GB_QUAD_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0},
 108
 109         { 0x8086, E1000_DEV_ID_82547EI,             PCI_ANY_ID, PCI_ANY_ID, 0},
 110         { 0x8086, E1000_DEV_ID_82547EI_MOBILE,      PCI_ANY_ID, PCI_ANY_ID, 0},
 111         { 0x8086, E1000_DEV_ID_82547GI,             PCI_ANY_ID, PCI_ANY_ID, 0},
 112
 113         { 0x8086, E1000_DEV_ID_82573E,              PCI_ANY_ID, PCI_ANY_ID, 0},
 114         { 0x8086, E1000_DEV_ID_82573E_IAMT,         PCI_ANY_ID, PCI_ANY_ID, 0},
 115
 116         /* required last entry */
 117         { 0, 0, 0, 0, 0}
 118 };
 119
 120 /*********************************************************************
 121  *  Table of branding strings for all supported NICs.
 122  *********************************************************************/
 123
 124 static char *em_strings[] = {
 125         "Intel(R) PRO/1000 Network Connection"
 126 };
 127
 128 /*********************************************************************
 129  *  Function prototypes
 130  *********************************************************************/
 131 static int  em_probe(device_t);
 132 static int  em_attach(device_t);
 133 static int  em_detach(device_t);
 134 static int  em_shutdown(device_t);
 135 static void em_intr(void *);
 136 static void em_start(struct ifnet *);
 137 static int  em_ioctl(struct ifnet *, u_long, caddr_t);
 138 static void em_watchdog(struct ifnet *);
 139 static void em_init(void *);
 140 static void em_init_locked(struct adapter *);
 141 static void em_stop(void *);
 142 static void em_media_status(struct ifnet *, struct ifmediareq *);
 143 static int  em_media_change(struct ifnet *);
 144 static void em_identify_hardware(struct adapter *);
 145 static int  em_allocate_pci_resources(struct adapter *);
 146 static void em_free_pci_resources(struct adapter *);
 147 static void em_local_timer(void *);
 148 static int  em_hardware_init(struct adapter *);
 149 static void em_setup_interface(device_t, struct adapter *);
 150 static int  em_setup_transmit_structures(struct adapter *);
 151 static void em_initialize_transmit_unit(struct adapter *);
 152 static int  em_setup_receive_structures(struct adapter *);
 153 static void em_initialize_receive_unit(struct adapter *);
 154 static void em_enable_intr(struct adapter *);
 155 static void em_disable_intr(struct adapter *);
 156 static void em_free_transmit_structures(struct adapter *);
 157 static void em_free_receive_structures(struct adapter *);
 158 static void em_update_stats_counters(struct adapter *);
 159 static void em_clean_transmit_interrupts(struct adapter *);
 160 static int  em_allocate_receive_structures(struct adapter *);
 161 static int  em_allocate_transmit_structures(struct adapter *);
 162 static void em_process_receive_interrupts(struct adapter *, int);
 163 static void em_receive_checksum(struct adapter *,
 164                                 struct em_rx_desc *,
 165                                 struct mbuf *);
 166 static void em_transmit_checksum_setup(struct adapter *,
 167                                        struct mbuf *,
 168                                        u_int32_t *,
 169                                        u_int32_t *);
 170 static void em_set_promisc(struct adapter *);
 171 static void em_disable_promisc(struct adapter *);
 172 static void em_set_multi(struct adapter *);
 173 static void em_print_hw_stats(struct adapter *);
 174 static void em_print_link_status(struct adapter *);
 175 static int  em_get_buf(int i, struct adapter *,
 176                        struct mbuf *);
 177 static void em_enable_vlans(struct adapter *);
 178 static void em_disable_vlans(struct adapter *);
 179 static int  em_encap(struct adapter *, struct mbuf **);
 180 static void em_smartspeed(struct adapter *);
 181 static int  em_82547_fifo_workaround(struct adapter *, int);
 182 static void em_82547_update_fifo_head(struct adapter *, int);
 183 static int  em_82547_tx_fifo_reset(struct adapter *);
 184 static void em_82547_move_tail(void *arg);
 185 static void em_82547_move_tail_locked(struct adapter *);
 186 static int  em_dma_malloc(struct adapter *, bus_size_t,
 187                           struct em_dma_alloc *, int);
 188 static void em_dma_free(struct adapter *, struct em_dma_alloc *);
 189 static void em_print_debug_info(struct adapter *);
 190 static int  em_is_valid_ether_addr(u_int8_t *);
 191 static int  em_sysctl_stats(SYSCTL_HANDLER_ARGS);
 192 static int  em_sysctl_debug_info(SYSCTL_HANDLER_ARGS);
 193 static u_int32_t em_fill_descriptors (u_int64_t address,
 194                                       u_int32_t length,
 195                                       PDESC_ARRAY desc_array);
 196 static int  em_sysctl_int_delay(SYSCTL_HANDLER_ARGS);
 197 static void em_add_int_delay_sysctl(struct adapter *, const char *,
 198                                     const char *, struct em_int_delay_info *,
 199                                     int, int);
 200
 201 /*********************************************************************
 202  *  FreeBSD Device Interface Entry Points
 203  *********************************************************************/
 204
 205 static device_method_t em_methods[] = {
 206         /* Device interface */
 207         DEVMETHOD(device_probe, em_probe),
 208         DEVMETHOD(device_attach, em_attach),
 209         DEVMETHOD(device_detach, em_detach),
 210         DEVMETHOD(device_shutdown, em_shutdown),
 211         {0, 0}
 212 };
 213
 214 static driver_t em_driver = {
 215         "em", em_methods, sizeof(struct adapter ),
 216 };
 217
 218 static devclass_t em_devclass;
 219 DRIVER_MODULE(em, pci, em_driver, em_devclass, 0, 0);
 220 MODULE_DEPEND(em, pci, 1, 1, 1);
 221 MODULE_DEPEND(em, ether, 1, 1, 1);
 222
 223 /*********************************************************************
 224  *  Tunable default values.
 225  *********************************************************************/
 226
 227 #define E1000_TICKS_TO_USECS(ticks)     ((1024 * (ticks) + 500) / 1000)
 228 #define E1000_USECS_TO_TICKS(usecs)     ((1000 * (usecs) + 512) / 1024)
 229
 230 static int em_tx_int_delay_dflt = E1000_TICKS_TO_USECS(EM_TIDV);
 231 static int em_rx_int_delay_dflt = E1000_TICKS_TO_USECS(EM_RDTR);
 232 static int em_tx_abs_int_delay_dflt = E1000_TICKS_TO_USECS(EM_TADV);
 233 static int em_rx_abs_int_delay_dflt = E1000_TICKS_TO_USECS(EM_RADV);
 234
 235 TUNABLE_INT("hw.em.tx_int_delay", &em_tx_int_delay_dflt);
 236 TUNABLE_INT("hw.em.rx_int_delay", &em_rx_int_delay_dflt);
 237 TUNABLE_INT("hw.em.tx_abs_int_delay", &em_tx_abs_int_delay_dflt);
 238 TUNABLE_INT("hw.em.rx_abs_int_delay", &em_rx_abs_int_delay_dflt);
 239
 240 /*********************************************************************
 241  *  Device identification routine
 242  *
 243  *  em_probe determines if the driver should be loaded on
 244  *  adapter based on PCI vendor/device id of the adapter.
 245  *
 246  *  return BUS_PROBE_DEFAULT on success, positive on failure
 247  *********************************************************************/
 248
 249 static int
 250 em_probe(device_t dev)
 251 {
 252         em_vendor_info_t *ent;
 253
 254         u_int16_t       pci_vendor_id = 0;
 255         u_int16_t       pci_device_id = 0;
 256         u_int16_t       pci_subvendor_id = 0;
 257         u_int16_t       pci_subdevice_id = 0;
 258         char            adapter_name[60];
 259
 260         INIT_DEBUGOUT("em_probe: begin");
 261
 262         pci_vendor_id = pci_get_vendor(dev);
 263         if (pci_vendor_id != EM_VENDOR_ID)
 264                 return(ENXIO);
 265
 266         pci_device_id = pci_get_device(dev);
 267         pci_subvendor_id = pci_get_subvendor(dev);
 268         pci_subdevice_id = pci_get_subdevice(dev);
 269
 270         ent = em_vendor_info_array;
 271         while (ent->vendor_id != 0) {
 272                 if ((pci_vendor_id == ent->vendor_id) &&
 273                     (pci_device_id == ent->device_id) &&
 274
 275                     ((pci_subvendor_id == ent->subvendor_id) ||
 276                      (ent->subvendor_id == PCI_ANY_ID)) &&
 277
 278                     ((pci_subdevice_id == ent->subdevice_id) ||
 279                      (ent->subdevice_id == PCI_ANY_ID))) {
 280                         sprintf(adapter_name, "%s, Version - %s",
 281                                 em_strings[ent->index],
 282                                 em_driver_version);
 283                         device_set_desc_copy(dev, adapter_name);
 284                         return(BUS_PROBE_DEFAULT);
 285                 }
 286                 ent++;
 287         }
 288
 289         return(ENXIO);
 290 }
 291
 292 /*********************************************************************
 293  *  Device initialization routine
 294  *
 295  *  The attach entry point is called when the driver is being loaded.
 296  *  This routine identifies the type of hardware, allocates all resources
 297  *  and initializes the hardware.
 298  *
 299  *  return 0 on success, positive on failure
 300  *********************************************************************/
 301
 302 static int
 303 em_attach(device_t dev)
 304 {
 305         struct adapter * adapter;
 306         int             tsize, rsize;
 307         int             error = 0;
 308
 309         INIT_DEBUGOUT("em_attach: begin");
 310
 311         /* Allocate, clear, and link in our adapter structure */
 312         if (!(adapter = device_get_softc(dev))) {
 313                 printf("em: adapter structure allocation failed\n");
 314                 return(ENOMEM);
 315         }
 316         bzero(adapter, sizeof(struct adapter ));
 317         adapter->dev = dev;
 318         adapter->osdep.dev = dev;
 319         adapter->unit = device_get_unit(dev);
 320         EM_LOCK_INIT(adapter, device_get_nameunit(dev));
 321
 322         if (em_adapter_list != NULL)
 323                 em_adapter_list->prev = adapter;
 324         adapter->next = em_adapter_list;
 325         em_adapter_list = adapter;
 326
 327         /* SYSCTL stuff */
 328         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 329                         SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 330                         OID_AUTO, "debug_info", CTLTYPE_INT|CTLFLAG_RW,
 331                         (void *)adapter, 0,
 332                         em_sysctl_debug_info, "I", "Debug Information");
 333
 334         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 335                         SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 336                         OID_AUTO, "stats", CTLTYPE_INT|CTLFLAG_RW,
 337                         (void *)adapter, 0,
 338                         em_sysctl_stats, "I", "Statistics");
 339
 340         callout_init(&adapter->timer, CALLOUT_MPSAFE);
 341         callout_init(&adapter->tx_fifo_timer, CALLOUT_MPSAFE);
 342
 343         /* Determine hardware revision */
 344         em_identify_hardware(adapter);
 345
 346         /* Set up some sysctls for the tunable interrupt delays */
 347         em_add_int_delay_sysctl(adapter, "rx_int_delay",
 348             "receive interrupt delay in usecs", &adapter->rx_int_delay,
 349             E1000_REG_OFFSET(&adapter->hw, RDTR), em_rx_int_delay_dflt);
 350         em_add_int_delay_sysctl(adapter, "tx_int_delay",
 351             "transmit interrupt delay in usecs", &adapter->tx_int_delay,
 352             E1000_REG_OFFSET(&adapter->hw, TIDV), em_tx_int_delay_dflt);
 353         if (adapter->hw.mac_type >= em_82540) {
 354                 em_add_int_delay_sysctl(adapter, "rx_abs_int_delay",
 355                     "receive interrupt delay limit in usecs",
 356                     &adapter->rx_abs_int_delay,
 357                     E1000_REG_OFFSET(&adapter->hw, RADV),
 358                     em_rx_abs_int_delay_dflt);
 359                 em_add_int_delay_sysctl(adapter, "tx_abs_int_delay",
 360                     "transmit interrupt delay limit in usecs",
 361                     &adapter->tx_abs_int_delay,
 362                     E1000_REG_OFFSET(&adapter->hw, TADV),
 363                     em_tx_abs_int_delay_dflt);
 364         }
 365
 366         /* Parameters (to be read from user) */
 367         adapter->num_tx_desc = EM_MAX_TXD;
 368         adapter->num_rx_desc = EM_MAX_RXD;
 369         adapter->hw.autoneg = DO_AUTO_NEG;
 370         adapter->hw.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT;
 371         adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
 372         adapter->hw.tbi_compatibility_en = TRUE;
 373         adapter->rx_buffer_len = EM_RXBUFFER_2048;
 374
 375         /*
 376          * These parameters control the automatic generation(Tx) and
 377          * response(Rx) to Ethernet PAUSE frames.
 378          */
 379         adapter->hw.fc_high_water = FC_DEFAULT_HI_THRESH;
 380         adapter->hw.fc_low_water  = FC_DEFAULT_LO_THRESH;
 381         adapter->hw.fc_pause_time = FC_DEFAULT_TX_TIMER;
 382         adapter->hw.fc_send_xon   = TRUE;
 383         adapter->hw.fc = em_fc_full;
 384
 385         adapter->hw.phy_init_script = 1;
 386         adapter->hw.phy_reset_disable = FALSE;
 387
 388 #ifndef EM_MASTER_SLAVE
 389         adapter->hw.master_slave = em_ms_hw_default;
 390 #else
 391         adapter->hw.master_slave = EM_MASTER_SLAVE;
 392 #endif
 393         /*
 394          * Set the max frame size assuming standard ethernet
 395          * sized frames
 396          */
 397         adapter->hw.max_frame_size =
 398                 ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN;
 399
 400         adapter->hw.min_frame_size =
 401                 MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN;
 402
 403         /*
 404          * This controls when hardware reports transmit completion
 405          * status.
 406          */
 407         adapter->hw.report_tx_early = 1;
 408
 409
 410         if (em_allocate_pci_resources(adapter)) {
 411                 printf("em%d: Allocation of PCI resources failed\n",
 412                        adapter->unit);
 413                 error = ENXIO;
 414                 goto err_pci;
 415         }
 416
 417
 418         /* Initialize eeprom parameters */
 419         em_init_eeprom_params(&adapter->hw);
 420
 421         tsize = EM_ROUNDUP(adapter->num_tx_desc *
 422                            sizeof(struct em_tx_desc), 4096);
 423
 424         /* Allocate Transmit Descriptor ring */
 425         if (em_dma_malloc(adapter, tsize, &adapter->txdma, BUS_DMA_NOWAIT)) {
 426                 printf("em%d: Unable to allocate tx_desc memory\n",
 427                        adapter->unit);
 428                 error = ENOMEM;
 429                 goto err_tx_desc;
 430         }
 431         adapter->tx_desc_base = (struct em_tx_desc *) adapter->txdma.dma_vaddr;
 432
 433         rsize = EM_ROUNDUP(adapter->num_rx_desc *
 434                            sizeof(struct em_rx_desc), 4096);
 435
 436         /* Allocate Receive Descriptor ring */
 437         if (em_dma_malloc(adapter, rsize, &adapter->rxdma, BUS_DMA_NOWAIT)) {
 438                 printf("em%d: Unable to allocate rx_desc memory\n",
 439                         adapter->unit);
 440                 error = ENOMEM;
 441                 goto err_rx_desc;
 442         }
 443         adapter->rx_desc_base = (struct em_rx_desc *) adapter->rxdma.dma_vaddr;
 444
 445         /* Initialize the hardware */
 446         if (em_hardware_init(adapter)) {
 447                 printf("em%d: Unable to initialize the hardware\n",
 448                        adapter->unit);
 449                 error = EIO;
 450                 goto err_hw_init;
 451         }
 452
 453         /* Copy the permanent MAC address out of the EEPROM */
 454         if (em_read_mac_addr(&adapter->hw) < 0) {
 455                 printf("em%d: EEPROM read error while reading mac address\n",
 456                        adapter->unit);
 457                 error = EIO;
 458                 goto err_mac_addr;
 459         }
 460
 461         if (!em_is_valid_ether_addr(adapter->hw.mac_addr)) {
 462                 printf("em%d: Invalid mac address\n", adapter->unit);
 463                 error = EIO;
 464                 goto err_mac_addr;
 465         }
 466
 467         /* Setup OS specific network interface */
 468         em_setup_interface(dev, adapter);
 469
 470         /* Initialize statistics */
 471         em_clear_hw_cntrs(&adapter->hw);
 472         em_update_stats_counters(adapter);
 473         adapter->hw.get_link_status = 1;
 474         em_check_for_link(&adapter->hw);
 475
 476         /* Print the link status */
 477         if (adapter->link_active == 1) {
 478                 em_get_speed_and_duplex(&adapter->hw, &adapter->link_speed,
 479                                         &adapter->link_duplex);
 480                 printf("em%d:  Speed:%d Mbps  Duplex:%s\n",
 481                        adapter->unit,
 482                        adapter->link_speed,
 483                        adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half");
 484         } else
 485                 printf("em%d:  Speed:N/A  Duplex:N/A\n", adapter->unit);
 486
 487         /* Identify 82544 on PCIX */
 488         em_get_bus_info(&adapter->hw);
 489         if(adapter->hw.bus_type == em_bus_type_pcix &&
 490            adapter->hw.mac_type == em_82544) {
 491                 adapter->pcix_82544 = TRUE;
 492         }
 493         else {
 494                 adapter->pcix_82544 = FALSE;
 495         }
 496         INIT_DEBUGOUT("em_attach: end");
 497         return(0);
 498
 499 err_mac_addr:
 500 err_hw_init:
 501         em_dma_free(adapter, &adapter->rxdma);
 502 err_rx_desc:
 503         em_dma_free(adapter, &adapter->txdma);
 504 err_tx_desc:
 505 err_pci:
 506         em_free_pci_resources(adapter);
 507         return(error);
 508
 509 }
 510
 511 /*********************************************************************
 512  *  Device removal routine
 513  *
 514  *  The detach entry point is called when the driver is being removed.
 515  *  This routine stops the adapter and deallocates all the resources
 516  *  that were allocated for driver operation.
 517  *
 518  *  return 0 on success, positive on failure
 519  *********************************************************************/
 520
 521 static int
 522 em_detach(device_t dev)
 523 {
 524         struct adapter * adapter = device_get_softc(dev);
 525         struct ifnet   *ifp = adapter->ifp;
 526
 527         INIT_DEBUGOUT("em_detach: begin");
 528
 529         EM_LOCK(adapter);
 530         adapter->in_detach = 1;
 531         em_stop(adapter);
 532         em_phy_hw_reset(&adapter->hw);
 533         EM_UNLOCK(adapter);
 534 #if __FreeBSD_version < 500000
 535         ether_ifdetach(adapter->ifp, ETHER_BPF_SUPPORTED);
 536 #else
 537         ether_ifdetach(adapter->ifp);
 538         if_free(ifp);
 539 #endif
 540         em_free_pci_resources(adapter);
 541         bus_generic_detach(dev);
 542
 543         /* Free Transmit Descriptor ring */
 544         if (adapter->tx_desc_base) {
 545                 em_dma_free(adapter, &adapter->txdma);
 546                 adapter->tx_desc_base = NULL;
 547         }
 548
 549         /* Free Receive Descriptor ring */
 550         if (adapter->rx_desc_base) {
 551                 em_dma_free(adapter, &adapter->rxdma);
 552                 adapter->rx_desc_base = NULL;
 553         }
 554
 555         /* Remove from the adapter list */
 556         if (em_adapter_list == adapter)
 557                 em_adapter_list = adapter->next;
 558         if (adapter->next != NULL)
 559                 adapter->next->prev = adapter->prev;
 560         if (adapter->prev != NULL)
 561                 adapter->prev->next = adapter->next;
 562
 563         EM_LOCK_DESTROY(adapter);
 564
 565         return(0);
 566 }
 567
 568 /*********************************************************************
 569  *
 570  *  Shutdown entry point
 571  *
 572  **********************************************************************/
 573
 574 static int
 575 em_shutdown(device_t dev)
 576 {
 577         struct adapter *adapter = device_get_softc(dev);
 578         EM_LOCK(adapter);
 579         em_stop(adapter);
 580         EM_UNLOCK(adapter);
 581         return(0);
 582 }
 583
 584
 585 /*********************************************************************
 586  *  Transmit entry point
 587  *
 588  *  em_start is called by the stack to initiate a transmit.
 589  *  The driver will remain in this routine as long as there are
 590  *  packets to transmit and transmit resources are available.
 591  *  In case resources are not available stack is notified and
 592  *  the packet is requeued.
 593  **********************************************************************/
 594
 595 static void
 596 em_start_locked(struct ifnet *ifp)
 597 {
 598         struct mbuf    *m_head;
 599         struct adapter *adapter = ifp->if_softc;
 600
 601         mtx_assert(&adapter->mtx, MA_OWNED);
 602
 603         if (!adapter->link_active)
 604                 return;
 605
 606         while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
 607
 608                 IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
 609
 610                 if (m_head == NULL) break;
 611
 612                 /*
 613                  * em_encap() can modify our pointer, and or make it NULL on
 614                  * failure.  In that event, we can't requeue.
 615                  */
 616                 if (em_encap(adapter, &m_head)) {
 617                         if (m_head == NULL)
 618                                 break;
 619                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 620                         IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
 621                         break;
 622                 }
 623
 624                 /* Send a copy of the frame to the BPF listener */
 625 #if __FreeBSD_version < 500000
 626                 if (ifp->if_bpf)
 627                         bpf_mtap(ifp, m_head);
 628 #else
 629                 BPF_MTAP(ifp, m_head);
 630 #endif
 631
 632                 /* Set timeout in case hardware has problems transmitting */
 633                 ifp->if_timer = EM_TX_TIMEOUT;
 634
 635         }
 636         return;
 637 }
 638
 639 static void
 640 em_start(struct ifnet *ifp)
 641 {
 642         struct adapter *adapter = ifp->if_softc;
 643
 644         EM_LOCK(adapter);
 645         em_start_locked(ifp);
 646         EM_UNLOCK(adapter);
 647         return;
 648 }
 649
 650 /*********************************************************************
 651  *  Ioctl entry point
 652  *
 653  *  em_ioctl is called when the user wants to configure the
 654  *  interface.
 655  *
 656  *  return 0 on success, positive on failure
 657  **********************************************************************/
 658
 659 static int
 660 em_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 661 {
 662         int             mask, reinit, error = 0;
 663         struct ifreq   *ifr = (struct ifreq *) data;
 664         struct adapter * adapter = ifp->if_softc;
 665
 666         if (adapter->in_detach) return(error);
 667
 668         switch (command) {
 669         case SIOCSIFADDR:
 670         case SIOCGIFADDR:
 671                 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFADDR (Get/Set Interface Addr)");
 672                 ether_ioctl(ifp, command, data);
 673                 break;
 674         case SIOCSIFMTU:
 675                 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)");
 676                 if (ifr->ifr_mtu > MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN || \
 677                         /* 82573 does not support jumbo frames */
 678                         (adapter->hw.mac_type == em_82573 && ifr->ifr_mtu > ETHERMTU) ) {
 679                         error = EINVAL;
 680                 } else {
 681                         EM_LOCK(adapter);
 682                         ifp->if_mtu = ifr->ifr_mtu;
 683                         adapter->hw.max_frame_size =
 684                         ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
 685                         em_init_locked(adapter);
 686                         EM_UNLOCK(adapter);
 687                 }
 688                 break;
 689         case SIOCSIFFLAGS:
 690                 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)");
 691                 EM_LOCK(adapter);
 692                 if (ifp->if_flags & IFF_UP) {
 693                         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
 694                                 em_init_locked(adapter);
 695                         }
 696
 697                         em_disable_promisc(adapter);
 698                         em_set_promisc(adapter);
 699                 } else {
 700                         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
 701                                 em_stop(adapter);
 702                         }
 703                 }
 704                 EM_UNLOCK(adapter);
 705                 break;
 706         case SIOCADDMULTI:
 707         case SIOCDELMULTI:
 708                 IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI");
 709                 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
 710                         EM_LOCK(adapter);
 711                         em_disable_intr(adapter);
 712                         em_set_multi(adapter);
 713                         if (adapter->hw.mac_type == em_82542_rev2_0) {
 714                                 em_initialize_receive_unit(adapter);
 715                         }
 716 #ifdef DEVICE_POLLING
 717                         if (!(ifp->if_flags & IFF_POLLING))
 718 #endif
 719                                 em_enable_intr(adapter);
 720                         EM_UNLOCK(adapter);
 721                 }
 722                 break;
 723         case SIOCSIFMEDIA:
 724         case SIOCGIFMEDIA:
 725                 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)");
 726                 error = ifmedia_ioctl(ifp, ifr, &adapter->media, command);
 727                 break;
 728         case SIOCSIFCAP:
 729                 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)");
 730                 reinit = 0;
 731                 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
 732                 if (mask & IFCAP_POLLING)
 733                         ifp->if_capenable ^= IFCAP_POLLING;
 734                 if (mask & IFCAP_HWCSUM) {
 735                         ifp->if_capenable ^= IFCAP_HWCSUM;
 736                         reinit = 1;
 737                 }
 738                 if (mask & IFCAP_VLAN_HWTAGGING) {
 739                         ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
 740                         reinit = 1;
 741                 }
 742                 if (reinit && (ifp->if_drv_flags & IFF_DRV_RUNNING))
 743                         em_init(adapter);
 744                 break;
 745         default:
 746                 IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%x)", (int)command);
 747                 error = EINVAL;
 748         }
 749
 750         return(error);
 751 }
 752
 753 /*********************************************************************
 754  *  Watchdog entry point
 755  *
 756  *  This routine is called whenever hardware quits transmitting.
 757  *
 758  **********************************************************************/
 759
 760 static void
 761 em_watchdog(struct ifnet *ifp)
 762 {
 763         struct adapter * adapter;
 764         adapter = ifp->if_softc;
 765
 766         /* If we are in this routine because of pause frames, then
 767          * don't reset the hardware.
 768          */
 769         if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF) {
 770                 ifp->if_timer = EM_TX_TIMEOUT;
 771                 return;
 772         }
 773
 774         if (em_check_for_link(&adapter->hw))
 775                 printf("em%d: watchdog timeout -- resetting\n", adapter->unit);
 776
 777         ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
 778
 779         em_init(adapter);
 780
 781         ifp->if_oerrors++;
 782         return;
 783 }
 784
 785 /*********************************************************************
 786  *  Init entry point
 787  *
 788  *  This routine is used in two ways. It is used by the stack as
 789  *  init entry point in network interface structure. It is also used
 790  *  by the driver as a hw/sw initialization routine to get to a
 791  *  consistent state.
 792  *
 793  *  return 0 on success, positive on failure
 794  **********************************************************************/
 795
 796 static void
 797 em_init_locked(struct adapter * adapter)
 798 {
 799         struct ifnet   *ifp;
 800
 801         uint32_t        pba;
 802         ifp = adapter->ifp;
 803
 804         INIT_DEBUGOUT("em_init: begin");
 805
 806         mtx_assert(&adapter->mtx, MA_OWNED);
 807
 808         em_stop(adapter);
 809
 810         /* Packet Buffer Allocation (PBA)
 811          * Writing PBA sets the receive portion of the buffer
 812          * the remainder is used for the transmit buffer.
 813          *
 814          * Devices before the 82547 had a Packet Buffer of 64K.
 815          *   Default allocation: PBA=48K for Rx, leaving 16K for Tx.
 816          * After the 82547 the buffer was reduced to 40K.
 817          *   Default allocation: PBA=30K for Rx, leaving 10K for Tx.
 818          *   Note: default does not leave enough room for Jumbo Frame >10k.
 819          */
 820         if(adapter->hw.mac_type < em_82547) {
 821                 /* Total FIFO is 64K */
 822                 if(adapter->rx_buffer_len > EM_RXBUFFER_8192)
 823                         pba = E1000_PBA_40K; /* 40K for Rx, 24K for Tx */
 824                 else
 825                         pba = E1000_PBA_48K; /* 48K for Rx, 16K for Tx */
 826         } else {
 827                 /* Total FIFO is 40K */
 828                 if(adapter->hw.max_frame_size > EM_RXBUFFER_8192) {
 829                         pba = E1000_PBA_22K; /* 22K for Rx, 18K for Tx */
 830                 } else {
 831                         pba = E1000_PBA_30K; /* 30K for Rx, 10K for Tx */
 832                 }
 833                 adapter->tx_fifo_head = 0;
 834                 adapter->tx_head_addr = pba << EM_TX_HEAD_ADDR_SHIFT;
 835                 adapter->tx_fifo_size = (E1000_PBA_40K - pba) << EM_PBA_BYTES_SHIFT;
 836         }
 837         INIT_DEBUGOUT1("em_init: pba=%dK",pba);
 838         E1000_WRITE_REG(&adapter->hw, PBA, pba);
 839
 840         /* Get the latest mac address, User can use a LAA */
 841         bcopy(IFP2ENADDR(adapter->ifp), adapter->hw.mac_addr,
 842               ETHER_ADDR_LEN);
 843
 844         /* Initialize the hardware */
 845         if (em_hardware_init(adapter)) {
 846                 printf("em%d: Unable to initialize the hardware\n",
 847                        adapter->unit);
 848                 return;
 849         }
 850
 851         if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
 852                 em_enable_vlans(adapter);
 853
 854         /* Prepare transmit descriptors and buffers */
 855         if (em_setup_transmit_structures(adapter)) {
 856                 printf("em%d: Could not setup transmit structures\n",
 857                        adapter->unit);
 858                 em_stop(adapter);
 859                 return;
 860         }
 861         em_initialize_transmit_unit(adapter);
 862
 863         /* Setup Multicast table */
 864         em_set_multi(adapter);
 865
 866         /* Prepare receive descriptors and buffers */
 867         if (em_setup_receive_structures(adapter)) {
 868                 printf("em%d: Could not setup receive structures\n",
 869                        adapter->unit);
 870                 em_stop(adapter);
 871                 return;
 872         }
 873         em_initialize_receive_unit(adapter);
 874
 875         /* Don't loose promiscuous settings */
 876         em_set_promisc(adapter);
 877
 878         ifp->if_drv_flags |= IFF_DRV_RUNNING;
 879         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 880
 881         if (adapter->hw.mac_type >= em_82543) {
 882                 if (ifp->if_capenable & IFCAP_TXCSUM)
 883                         ifp->if_hwassist = EM_CHECKSUM_FEATURES;
 884                 else
 885                         ifp->if_hwassist = 0;
 886         }
 887
 888         callout_reset(&adapter->timer, hz, em_local_timer, adapter);
 889         em_clear_hw_cntrs(&adapter->hw);
 890 #ifdef DEVICE_POLLING
 891         /*
 892          * Only enable interrupts if we are not polling, make sure
 893          * they are off otherwise.
 894          */
 895         if (ifp->if_flags & IFF_POLLING)
 896                 em_disable_intr(adapter);
 897         else
 898 #endif /* DEVICE_POLLING */
 899                 em_enable_intr(adapter);
 900
 901         /* Don't reset the phy next time init gets called */
 902         adapter->hw.phy_reset_disable = TRUE;
 903
 904         return;
 905 }
 906
 907 static void
 908 em_init(void *arg)
 909 {
 910         struct adapter * adapter = arg;
 911
 912         EM_LOCK(adapter);
 913         em_init_locked(adapter);
 914         EM_UNLOCK(adapter);
 915         return;
 916 }
 917
 918
 919 #ifdef DEVICE_POLLING
 920 static poll_handler_t em_poll;
 921
 922 static void
 923 em_poll_locked(struct ifnet *ifp, enum poll_cmd cmd, int count)
 924 {
 925         struct adapter *adapter = ifp->if_softc;
 926         u_int32_t reg_icr;
 927
 928         mtx_assert(&adapter->mtx, MA_OWNED);
 929
 930         if (!(ifp->if_capenable & IFCAP_POLLING)) {
 931                 ether_poll_deregister(ifp);
 932                 cmd = POLL_DEREGISTER;
 933         }
 934         if (cmd == POLL_DEREGISTER) {       /* final call, enable interrupts */
 935                 em_enable_intr(adapter);
 936                 return;
 937         }
 938         if (cmd == POLL_AND_CHECK_STATUS) {
 939                 reg_icr = E1000_READ_REG(&adapter->hw, ICR);
 940                 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
 941                         callout_stop(&adapter->timer);
 942                         adapter->hw.get_link_status = 1;
 943                         em_check_for_link(&adapter->hw);
 944                         em_print_link_status(adapter);
 945                         callout_reset(&adapter->timer, hz, em_local_timer, adapter);
 946                 }
 947         }
 948         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
 949                 em_process_receive_interrupts(adapter, count);
 950                 em_clean_transmit_interrupts(adapter);
 951         }
 952
 953         if (ifp->if_drv_flags & IFF_DRV_RUNNING &&
 954             !IFQ_DRV_IS_EMPTY(&ifp->if_snd))
 955                 em_start_locked(ifp);
 956 }
 957
 958 static void
 959 em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
 960 {
 961         struct adapter *adapter = ifp->if_softc;
 962
 963         EM_LOCK(adapter);
 964         em_poll_locked(ifp, cmd, count);
 965         EM_UNLOCK(adapter);
 966 }
 967 #endif /* DEVICE_POLLING */
 968
 969 /*********************************************************************
 970  *
 971  *  Interrupt Service routine
 972  *
 973  **********************************************************************/
 974 static void
 975 em_intr(void *arg)
 976 {
 977         u_int32_t       loop_cnt = EM_MAX_INTR;
 978         u_int32_t       reg_icr;
 979         struct ifnet    *ifp;
 980         struct adapter  *adapter = arg;
 981
 982         EM_LOCK(adapter);
 983
 984         ifp = adapter->ifp;
 985
 986 #ifdef DEVICE_POLLING
 987         if (ifp->if_flags & IFF_POLLING) {
 988                 EM_UNLOCK(adapter);
 989                 return;
 990         }
 991
 992         if ((ifp->if_capenable & IFCAP_POLLING) &&
 993             ether_poll_register(em_poll, ifp)) {
 994                 em_disable_intr(adapter);
 995                 em_poll_locked(ifp, 0, 1);
 996                 EM_UNLOCK(adapter);
 997                 return;
 998         }
 999 #endif /* DEVICE_POLLING */
1000
1001         reg_icr = E1000_READ_REG(&adapter->hw, ICR);
1002         if (!reg_icr) {
1003                 EM_UNLOCK(adapter);
1004                 return;
1005         }
1006
1007         /* Link status change */
1008         if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
1009                 callout_stop(&adapter->timer);
1010                 adapter->hw.get_link_status = 1;
1011                 em_check_for_link(&adapter->hw);
1012                 em_print_link_status(adapter);
1013                 callout_reset(&adapter->timer, hz, em_local_timer, adapter);
1014         }
1015
1016         while (loop_cnt > 0) {
1017                 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1018                         em_process_receive_interrupts(adapter, -1);
1019                         em_clean_transmit_interrupts(adapter);
1020                 }
1021                 loop_cnt--;
1022         }
1023
1024         if (ifp->if_drv_flags & IFF_DRV_RUNNING &&
1025             !IFQ_DRV_IS_EMPTY(&ifp->if_snd))
1026                 em_start_locked(ifp);
1027
1028         EM_UNLOCK(adapter);
1029         return;
1030 }
1031
1032
1033
1034 /*********************************************************************
1035  *
1036  *  Media Ioctl callback
1037  *
1038  *  This routine is called whenever the user queries the status of
1039  *  the interface using ifconfig.
1040  *
1041  **********************************************************************/
1042 static void
1043 em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
1044 {
1045         struct adapter * adapter = ifp->if_softc;
1046
1047         INIT_DEBUGOUT("em_media_status: begin");
1048
1049         em_check_for_link(&adapter->hw);
1050         if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
1051                 if (adapter->link_active == 0) {
1052                         em_get_speed_and_duplex(&adapter->hw,
1053                                                 &adapter->link_speed,
1054                                                 &adapter->link_duplex);
1055                         adapter->link_active = 1;
1056                 }
1057         } else {
1058                 if (adapter->link_active == 1) {
1059                         adapter->link_speed = 0;
1060                         adapter->link_duplex = 0;
1061                         adapter->link_active = 0;
1062                 }
1063         }
1064
1065         ifmr->ifm_status = IFM_AVALID;
1066         ifmr->ifm_active = IFM_ETHER;
1067
1068         if (!adapter->link_active)
1069                 return;
1070
1071         ifmr->ifm_status |= IFM_ACTIVE;
1072
1073         if (adapter->hw.media_type == em_media_type_fiber) {
1074                 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX;
1075         } else {
1076                 switch (adapter->link_speed) {
1077                 case 10:
1078                         ifmr->ifm_active |= IFM_10_T;
1079                         break;
1080                 case 100:
1081                         ifmr->ifm_active |= IFM_100_TX;
1082                         break;
1083                 case 1000:
1084 #if __FreeBSD_version < 500000
1085                         ifmr->ifm_active |= IFM_1000_TX;
1086 #else
1087                         ifmr->ifm_active |= IFM_1000_T;
1088 #endif
1089                         break;
1090                 }
1091                 if (adapter->link_duplex == FULL_DUPLEX)
1092                         ifmr->ifm_active |= IFM_FDX;
1093                 else
1094                         ifmr->ifm_active |= IFM_HDX;
1095         }
1096         return;
1097 }
1098
1099 /*********************************************************************
1100  *
1101  *  Media Ioctl callback
1102  *
1103  *  This routine is called when the user changes speed/duplex using
1104  *  media/mediopt option with ifconfig.
1105  *
1106  **********************************************************************/
1107 static int
1108 em_media_change(struct ifnet *ifp)
1109 {
1110         struct adapter * adapter = ifp->if_softc;
1111         struct ifmedia  *ifm = &adapter->media;
1112
1113         INIT_DEBUGOUT("em_media_change: begin");
1114
1115         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
1116                 return(EINVAL);
1117
1118         switch (IFM_SUBTYPE(ifm->ifm_media)) {
1119         case IFM_AUTO:
1120                 adapter->hw.autoneg = DO_AUTO_NEG;
1121                 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
1122                 break;
1123         case IFM_1000_SX:
1124 #if __FreeBSD_version < 500000
1125         case IFM_1000_TX:
1126 #else
1127         case IFM_1000_T:
1128 #endif
1129                 adapter->hw.autoneg = DO_AUTO_NEG;
1130                 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
1131                 break;
1132         case IFM_100_TX:
1133                 adapter->hw.autoneg = FALSE;
1134                 adapter->hw.autoneg_advertised = 0;
1135                 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
1136                         adapter->hw.forced_speed_duplex = em_100_full;
1137                 else
1138                         adapter->hw.forced_speed_duplex = em_100_half;
1139                 break;
1140         case IFM_10_T:
1141                 adapter->hw.autoneg = FALSE;
1142                 adapter->hw.autoneg_advertised = 0;
1143                 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
1144                         adapter->hw.forced_speed_duplex = em_10_full;
1145                 else
1146                         adapter->hw.forced_speed_duplex = em_10_half;
1147                 break;
1148         default:
1149                 printf("em%d: Unsupported media type\n", adapter->unit);
1150         }
1151
1152         /* As the speed/duplex settings my have changed we need to
1153          * reset the PHY.
1154          */
1155         adapter->hw.phy_reset_disable = FALSE;
1156
1157         em_init(adapter);
1158
1159         return(0);
1160 }
1161
1162 /*********************************************************************
1163  *
1164  *  This routine maps the mbufs to tx descriptors.
1165  *
1166  *  return 0 on success, positive on failure
1167  **********************************************************************/
1168 static int
1169 em_encap(struct adapter *adapter, struct mbuf **m_headp)
1170 {
1171         u_int32_t       txd_upper;
1172         u_int32_t       txd_lower, txd_used = 0, txd_saved = 0;
1173         int             i, j, error;
1174         u_int64_t       address;
1175
1176         struct mbuf     *m_head;
1177
1178         /* For 82544 Workaround */
1179         DESC_ARRAY              desc_array;
1180         u_int32_t               array_elements;
1181         u_int32_t               counter;
1182
1183 #if __FreeBSD_version < 500000
1184         struct ifvlan *ifv = NULL;
1185 #else
1186         struct m_tag    *mtag;
1187 #endif
1188         bus_dma_segment_t       segs[EM_MAX_SCATTER];
1189         bus_dmamap_t            map;
1190         int                     nsegs;
1191         struct em_buffer   *tx_buffer = NULL;
1192         struct em_tx_desc *current_tx_desc = NULL;
1193         struct ifnet   *ifp = adapter->ifp;
1194
1195         m_head = *m_headp;
1196
1197         /*
1198          * Force a cleanup if number of TX descriptors
1199          * available hits the threshold
1200          */
1201         if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
1202                 em_clean_transmit_interrupts(adapter);
1203                 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
1204                         adapter->no_tx_desc_avail1++;
1205                         return(ENOBUFS);
1206                 }
1207         }
1208
1209         /*
1210          * Map the packet for DMA.
1211          */
1212         if (bus_dmamap_create(adapter->txtag, BUS_DMA_NOWAIT, &map)) {
1213                 adapter->no_tx_map_avail++;
1214                 return (ENOMEM);
1215         }
1216         error = bus_dmamap_load_mbuf_sg(adapter->txtag, map, m_head, segs,
1217                                         &nsegs, BUS_DMA_NOWAIT);
1218         if (error != 0) {
1219                 adapter->no_tx_dma_setup++;
1220                 bus_dmamap_destroy(adapter->txtag, map);
1221                 return (error);
1222         }
1223         KASSERT(nsegs != 0, ("em_encap: empty packet"));
1224
1225         if (nsegs > adapter->num_tx_desc_avail) {
1226                 adapter->no_tx_desc_avail2++;
1227                 bus_dmamap_destroy(adapter->txtag, map);
1228                 return (ENOBUFS);
1229         }
1230
1231
1232         if (ifp->if_hwassist > 0) {
1233                 em_transmit_checksum_setup(adapter,  m_head,
1234                                            &txd_upper, &txd_lower);
1235         } else
1236                 txd_upper = txd_lower = 0;
1237
1238
1239         /* Find out if we are in vlan mode */
1240 #if __FreeBSD_version < 500000
1241         if ((m_head->m_flags & (M_PROTO1|M_PKTHDR)) == (M_PROTO1|M_PKTHDR) &&
1242             m_head->m_pkthdr.rcvif != NULL &&
1243             m_head->m_pkthdr.rcvif->if_type == IFT_L2VLAN)
1244                 ifv = m_head->m_pkthdr.rcvif->if_softc;
1245 #else
1246         mtag = VLAN_OUTPUT_TAG(ifp, m_head);
1247 #endif
1248
1249         /*
1250          * When operating in promiscuous mode, hardware encapsulation for
1251          * packets is disabled.  This means we have to add the vlan
1252          * encapsulation in the driver, since it will have come down from the
1253          * VLAN layer with a tag instead of a VLAN header.
1254          */
1255         if (mtag != NULL && adapter->em_insert_vlan_header) {
1256                 struct ether_vlan_header *evl;
1257                 struct ether_header eh;
1258
1259                 m_head = m_pullup(m_head, sizeof(eh));
1260                 if (m_head == NULL) {
1261                         *m_headp = NULL;
1262                         bus_dmamap_destroy(adapter->txtag, map);
1263                         return (ENOBUFS);
1264                 }
1265                 eh = *mtod(m_head, struct ether_header *);
1266                 M_PREPEND(m_head, sizeof(*evl), M_DONTWAIT);
1267                 if (m_head == NULL) {
1268                         *m_headp = NULL;
1269                         bus_dmamap_destroy(adapter->txtag, map);
1270                         return (ENOBUFS);
1271                 }
1272                 m_head = m_pullup(m_head, sizeof(*evl));
1273                 if (m_head == NULL) {
1274                         *m_headp = NULL;
1275                         bus_dmamap_destroy(adapter->txtag, map);
1276                         return (ENOBUFS);
1277                 }
1278                 evl = mtod(m_head, struct ether_vlan_header *);
1279                 bcopy(&eh, evl, sizeof(*evl));
1280                 evl->evl_proto = evl->evl_encap_proto;
1281                 evl->evl_encap_proto = htons(ETHERTYPE_VLAN);
1282                 evl->evl_tag = htons(VLAN_TAG_VALUE(mtag));
1283                 m_tag_delete(m_head, mtag);
1284                 mtag = NULL;
1285                 *m_headp = m_head;
1286         }
1287
1288         i = adapter->next_avail_tx_desc;
1289         if (adapter->pcix_82544) {
1290                 txd_saved = i;
1291                 txd_used = 0;
1292         }
1293         for (j = 0; j < nsegs; j++) {
1294                 /* If adapter is 82544 and on PCIX bus */
1295                 if(adapter->pcix_82544) {
1296                         array_elements = 0;
1297                         address = htole64(segs[j].ds_addr);
1298                         /*
1299                          * Check the Address and Length combination and
1300                          * split the data accordingly
1301                          */
1302                         array_elements = em_fill_descriptors(address,
1303                                                              htole32(segs[j].ds_len),
1304                                                              &desc_array);
1305                         for (counter = 0; counter < array_elements; counter++) {
1306                                 if (txd_used == adapter->num_tx_desc_avail) {
1307                                          adapter->next_avail_tx_desc = txd_saved;
1308                                           adapter->no_tx_desc_avail2++;
1309                                           bus_dmamap_destroy(adapter->txtag, map);
1310                                           return (ENOBUFS);
1311                                 }
1312                                 tx_buffer = &adapter->tx_buffer_area[i];
1313                                 current_tx_desc = &adapter->tx_desc_base[i];
1314                                 current_tx_desc->buffer_addr = htole64(
1315                                         desc_array.descriptor[counter].address);
1316                                 current_tx_desc->lower.data = htole32(
1317                                         (adapter->txd_cmd | txd_lower |
1318                                          (u_int16_t)desc_array.descriptor[counter].length));
1319                                 current_tx_desc->upper.data = htole32((txd_upper));
1320                                 if (++i == adapter->num_tx_desc)
1321                                          i = 0;
1322
1323                                 tx_buffer->m_head = NULL;
1324                                 txd_used++;
1325                         }
1326                 } else {
1327                         tx_buffer = &adapter->tx_buffer_area[i];
1328                         current_tx_desc = &adapter->tx_desc_base[i];
1329
1330                         current_tx_desc->buffer_addr = htole64(segs[j].ds_addr);
1331                         current_tx_desc->lower.data = htole32(
1332                                 adapter->txd_cmd | txd_lower | segs[j].ds_len);
1333                         current_tx_desc->upper.data = htole32(txd_upper);
1334
1335                         if (++i == adapter->num_tx_desc)
1336                                 i = 0;
1337
1338                         tx_buffer->m_head = NULL;
1339                 }
1340         }
1341
1342         adapter->next_avail_tx_desc = i;
1343         if (adapter->pcix_82544) {
1344                 adapter->num_tx_desc_avail -= txd_used;
1345         }
1346         else {
1347                 adapter->num_tx_desc_avail -= nsegs;
1348         }
1349
1350 #if __FreeBSD_version < 500000
1351         if (ifv != NULL) {
1352                 /* Set the vlan id */
1353                 current_tx_desc->upper.fields.special = htole16(ifv->ifv_tag);
1354 #else
1355         if (mtag != NULL) {
1356                 /* Set the vlan id */
1357                 current_tx_desc->upper.fields.special = htole16(VLAN_TAG_VALUE(mtag));
1358 #endif
1359
1360                 /* Tell hardware to add tag */
1361                 current_tx_desc->lower.data |= htole32(E1000_TXD_CMD_VLE);
1362         }
1363
1364         tx_buffer->m_head = m_head;
1365         tx_buffer->map = map;
1366         bus_dmamap_sync(adapter->txtag, map, BUS_DMASYNC_PREWRITE);
1367
1368         /*
1369          * Last Descriptor of Packet needs End Of Packet (EOP)
1370          */
1371         current_tx_desc->lower.data |= htole32(E1000_TXD_CMD_EOP);
1372
1373         /*
1374          * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000
1375          * that this frame is available to transmit.
1376          */
1377         bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
1378             BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1379         if (adapter->hw.mac_type == em_82547 &&
1380             adapter->link_duplex == HALF_DUPLEX) {
1381                 em_82547_move_tail_locked(adapter);
1382         } else {
1383                 E1000_WRITE_REG(&adapter->hw, TDT, i);
1384                 if (adapter->hw.mac_type == em_82547) {
1385                         em_82547_update_fifo_head(adapter, m_head->m_pkthdr.len);
1386                 }
1387         }
1388
1389         return(0);
1390 }
1391
1392 /*********************************************************************
1393  *
1394  * 82547 workaround to avoid controller hang in half-duplex environment.
1395  * The workaround is to avoid queuing a large packet that would span
1396  * the internal Tx FIFO ring boundary. We need to reset the FIFO pointers
1397  * in this case. We do that only when FIFO is quiescent.
1398  *
1399  **********************************************************************/
1400 static void
1401 em_82547_move_tail_locked(struct adapter *adapter)
1402 {
1403         uint16_t hw_tdt;
1404         uint16_t sw_tdt;
1405         struct em_tx_desc *tx_desc;
1406         uint16_t length = 0;
1407         boolean_t eop = 0;
1408
1409         EM_LOCK_ASSERT(adapter);
1410
1411         hw_tdt = E1000_READ_REG(&adapter->hw, TDT);
1412         sw_tdt = adapter->next_avail_tx_desc;
1413
1414         while (hw_tdt != sw_tdt) {
1415                 tx_desc = &adapter->tx_desc_base[hw_tdt];
1416                 length += tx_desc->lower.flags.length;
1417                 eop = tx_desc->lower.data & E1000_TXD_CMD_EOP;
1418                 if(++hw_tdt == adapter->num_tx_desc)
1419                         hw_tdt = 0;
1420
1421                 if(eop) {
1422                         if (em_82547_fifo_workaround(adapter, length)) {
1423                                 adapter->tx_fifo_wrk_cnt++;
1424                                 callout_reset(&adapter->tx_fifo_timer, 1,
1425                                         em_82547_move_tail, adapter);
1426                                 break;
1427                         }
1428                         E1000_WRITE_REG(&adapter->hw, TDT, hw_tdt);
1429                         em_82547_update_fifo_head(adapter, length);
1430                         length = 0;
1431                 }
1432         }
1433         return;
1434 }
1435
1436 static void
1437 em_82547_move_tail(void *arg)
1438 {
1439         struct adapter *adapter = arg;
1440
1441         EM_LOCK(adapter);
1442         em_82547_move_tail_locked(adapter);
1443         EM_UNLOCK(adapter);
1444 }
1445
1446 static int
1447 em_82547_fifo_workaround(struct adapter *adapter, int len)
1448 {
1449         int fifo_space, fifo_pkt_len;
1450
1451         fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR);
1452
1453         if (adapter->link_duplex == HALF_DUPLEX) {
1454                 fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
1455
1456                 if (fifo_pkt_len >= (EM_82547_PKT_THRESH + fifo_space)) {
1457                         if (em_82547_tx_fifo_reset(adapter)) {
1458                                 return(0);
1459                         }
1460                         else {
1461                                 return(1);
1462                         }
1463                 }
1464         }
1465
1466         return(0);
1467 }
1468
1469 static void
1470 em_82547_update_fifo_head(struct adapter *adapter, int len)
1471 {
1472         int fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR);
1473
1474         /* tx_fifo_head is always 16 byte aligned */
1475         adapter->tx_fifo_head += fifo_pkt_len;
1476         if (adapter->tx_fifo_head >= adapter->tx_fifo_size) {
1477                 adapter->tx_fifo_head -= adapter->tx_fifo_size;
1478         }
1479
1480         return;
1481 }
1482
1483
1484 static int
1485 em_82547_tx_fifo_reset(struct adapter *adapter)
1486 {
1487         uint32_t tctl;
1488
1489         if ( (E1000_READ_REG(&adapter->hw, TDT) ==
1490               E1000_READ_REG(&adapter->hw, TDH)) &&
1491              (E1000_READ_REG(&adapter->hw, TDFT) ==
1492               E1000_READ_REG(&adapter->hw, TDFH)) &&
1493              (E1000_READ_REG(&adapter->hw, TDFTS) ==
1494               E1000_READ_REG(&adapter->hw, TDFHS)) &&
1495              (E1000_READ_REG(&adapter->hw, TDFPC) == 0)) {
1496
1497                 /* Disable TX unit */
1498                 tctl = E1000_READ_REG(&adapter->hw, TCTL);
1499                 E1000_WRITE_REG(&adapter->hw, TCTL, tctl & ~E1000_TCTL_EN);
1500
1501                 /* Reset FIFO pointers */
1502                 E1000_WRITE_REG(&adapter->hw, TDFT,  adapter->tx_head_addr);
1503                 E1000_WRITE_REG(&adapter->hw, TDFH,  adapter->tx_head_addr);
1504                 E1000_WRITE_REG(&adapter->hw, TDFTS, adapter->tx_head_addr);
1505                 E1000_WRITE_REG(&adapter->hw, TDFHS, adapter->tx_head_addr);
1506
1507                 /* Re-enable TX unit */
1508                 E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
1509                 E1000_WRITE_FLUSH(&adapter->hw);
1510
1511                 adapter->tx_fifo_head = 0;
1512                 adapter->tx_fifo_reset_cnt++;
1513
1514                 return(TRUE);
1515         }
1516         else {
1517                 return(FALSE);
1518         }
1519 }
1520
1521 static void
1522 em_set_promisc(struct adapter * adapter)
1523 {
1524
1525         u_int32_t       reg_rctl;
1526         struct ifnet   *ifp = adapter->ifp;
1527
1528         reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1529
1530         if (ifp->if_flags & IFF_PROMISC) {
1531                 reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
1532                 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1533                 /* Disable VLAN stripping in promiscous mode
1534                  * This enables bridging of vlan tagged frames to occur
1535                  * and also allows vlan tags to be seen in tcpdump
1536                  */
1537                 if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
1538                         em_disable_vlans(adapter);
1539                 adapter->em_insert_vlan_header = 1;
1540         } else if (ifp->if_flags & IFF_ALLMULTI) {
1541                 reg_rctl |= E1000_RCTL_MPE;
1542                 reg_rctl &= ~E1000_RCTL_UPE;
1543                 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1544                 adapter->em_insert_vlan_header = 0;
1545         } else
1546                 adapter->em_insert_vlan_header = 0;
1547
1548         return;
1549 }
1550
1551 static void
1552 em_disable_promisc(struct adapter * adapter)
1553 {
1554         u_int32_t       reg_rctl;
1555         struct ifnet   *ifp = adapter->ifp;
1556
1557         reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1558
1559         reg_rctl &=  (~E1000_RCTL_UPE);
1560         reg_rctl &=  (~E1000_RCTL_MPE);
1561         E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1562
1563         if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
1564                 em_enable_vlans(adapter);
1565         adapter->em_insert_vlan_header = 0;
1566
1567         return;
1568 }
1569
1570
1571 /*********************************************************************
1572  *  Multicast Update
1573  *
1574  *  This routine is called whenever multicast address list is updated.
1575  *
1576  **********************************************************************/
1577
1578 static void
1579 em_set_multi(struct adapter * adapter)
1580 {
1581         u_int32_t reg_rctl = 0;
1582         u_int8_t  mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS];
1583         struct ifmultiaddr  *ifma;
1584         int mcnt = 0;
1585         struct ifnet   *ifp = adapter->ifp;
1586
1587         IOCTL_DEBUGOUT("em_set_multi: begin");
1588
1589         if (adapter->hw.mac_type == em_82542_rev2_0) {
1590                 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1591                 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
1592                         em_pci_clear_mwi(&adapter->hw);
1593                 }
1594                 reg_rctl |= E1000_RCTL_RST;
1595                 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1596                 msec_delay(5);
1597         }
1598
1599         IF_ADDR_LOCK(ifp);
1600 #if __FreeBSD_version < 500000
1601         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1602 #else
1603         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1604 #endif
1605                 if (ifma->ifma_addr->sa_family != AF_LINK)
1606                         continue;
1607
1608                 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) break;
1609
1610                 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
1611                       &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS);
1612                 mcnt++;
1613         }
1614         IF_ADDR_UNLOCK(ifp);
1615
1616         if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) {
1617                 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1618                 reg_rctl |= E1000_RCTL_MPE;
1619                 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1620         } else
1621                 em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0, 1);
1622
1623         if (adapter->hw.mac_type == em_82542_rev2_0) {
1624                 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1625                 reg_rctl &= ~E1000_RCTL_RST;
1626                 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1627                 msec_delay(5);
1628                 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
1629                         em_pci_set_mwi(&adapter->hw);
1630                 }
1631         }
1632
1633         return;
1634 }
1635
1636
1637 /*********************************************************************
1638  *  Timer routine
1639  *
1640  *  This routine checks for link status and updates statistics.
1641  *
1642  **********************************************************************/
1643
1644 static void
1645 em_local_timer(void *arg)
1646 {
1647         struct ifnet   *ifp;
1648         struct adapter * adapter = arg;
1649         ifp = adapter->ifp;
1650
1651         EM_LOCK(adapter);
1652
1653         em_check_for_link(&adapter->hw);
1654         em_print_link_status(adapter);
1655         em_update_stats_counters(adapter);
1656         if (em_display_debug_stats && ifp->if_drv_flags & IFF_DRV_RUNNING) {
1657                 em_print_hw_stats(adapter);
1658         }
1659         em_smartspeed(adapter);
1660
1661         callout_reset(&adapter->timer, hz, em_local_timer, adapter);
1662
1663         EM_UNLOCK(adapter);
1664         return;
1665 }
1666
1667 static void
1668 em_print_link_status(struct adapter * adapter)
1669 {
1670         struct ifnet *ifp = adapter->ifp;
1671
1672         if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
1673                 if (adapter->link_active == 0) {
1674                         em_get_speed_and_duplex(&adapter->hw,
1675                                                 &adapter->link_speed,
1676                                                 &adapter->link_duplex);
1677                         if (bootverbose)
1678                                 printf("em%d: Link is up %d Mbps %s\n",
1679                                        adapter->unit,
1680                                        adapter->link_speed,
1681                                        ((adapter->link_duplex == FULL_DUPLEX) ?
1682                                         "Full Duplex" : "Half Duplex"));
1683                         adapter->link_active = 1;
1684                         adapter->smartspeed = 0;
1685                         if_link_state_change(ifp, LINK_STATE_UP);
1686                 }
1687         } else {
1688                 if (adapter->link_active == 1) {
1689                         adapter->link_speed = 0;
1690                         adapter->link_duplex = 0;
1691                         if (bootverbose)
1692                                 printf("em%d: Link is Down\n", adapter->unit);
1693                         adapter->link_active = 0;
1694                         if_link_state_change(ifp, LINK_STATE_DOWN);
1695                 }
1696         }
1697
1698         return;
1699 }
1700
1701 /*********************************************************************
1702  *
1703  *  This routine disables all traffic on the adapter by issuing a
1704  *  global reset on the MAC and deallocates TX/RX buffers.
1705  *
1706  **********************************************************************/
1707
1708 static void
1709 em_stop(void *arg)
1710 {
1711         struct ifnet   *ifp;
1712         struct adapter * adapter = arg;
1713         ifp = adapter->ifp;
1714
1715         mtx_assert(&adapter->mtx, MA_OWNED);
1716
1717         INIT_DEBUGOUT("em_stop: begin");
1718 #ifdef DEVICE_POLLING
1719         ether_poll_deregister(ifp);
1720 #endif
1721         em_disable_intr(adapter);
1722         em_reset_hw(&adapter->hw);
1723         callout_stop(&adapter->timer);
1724         callout_stop(&adapter->tx_fifo_timer);
1725         em_free_transmit_structures(adapter);
1726         em_free_receive_structures(adapter);
1727
1728
1729         /* Tell the stack that the interface is no longer active */
1730         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
1731
1732         return;
1733 }
1734
1735
1736 /*********************************************************************
1737  *
1738  *  Determine hardware revision.
1739  *
1740  **********************************************************************/
1741 static void
1742 em_identify_hardware(struct adapter * adapter)
1743 {
1744         device_t dev = adapter->dev;
1745
1746         /* Make sure our PCI config space has the necessary stuff set */
1747         adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2);
1748         if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) &&
1749               (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) {
1750                 printf("em%d: Memory Access and/or Bus Master bits were not set!\n",
1751                        adapter->unit);
1752                 adapter->hw.pci_cmd_word |=
1753                 (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN);
1754                 pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2);
1755         }
1756
1757         /* Save off the information about this board */
1758         adapter->hw.vendor_id = pci_get_vendor(dev);
1759         adapter->hw.device_id = pci_get_device(dev);
1760         adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1);
1761         adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2);
1762         adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2);
1763
1764         /* Identify the MAC */
1765         if (em_set_mac_type(&adapter->hw))
1766                 printf("em%d: Unknown MAC Type\n", adapter->unit);
1767
1768         if(adapter->hw.mac_type == em_82541 ||
1769            adapter->hw.mac_type == em_82541_rev_2 ||
1770            adapter->hw.mac_type == em_82547 ||
1771            adapter->hw.mac_type == em_82547_rev_2)
1772                 adapter->hw.phy_init_script = TRUE;
1773
1774         return;
1775 }
1776
1777 static int
1778 em_allocate_pci_resources(struct adapter * adapter)
1779 {
1780         int             i, val, rid;
1781         device_t        dev = adapter->dev;
1782
1783         rid = EM_MMBA;
1784         adapter->res_memory = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
1785                                                      &rid, RF_ACTIVE);
1786         if (!(adapter->res_memory)) {
1787                 printf("em%d: Unable to allocate bus resource: memory\n",
1788                        adapter->unit);
1789                 return(ENXIO);
1790         }
1791         adapter->osdep.mem_bus_space_tag =
1792         rman_get_bustag(adapter->res_memory);
1793         adapter->osdep.mem_bus_space_handle =
1794         rman_get_bushandle(adapter->res_memory);
1795         adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle;
1796
1797
1798         if (adapter->hw.mac_type > em_82543) {
1799                 /* Figure our where our IO BAR is ? */
1800                 rid = EM_MMBA;
1801                 for (i = 0; i < 5; i++) {
1802                         val = pci_read_config(dev, rid, 4);
1803                         if (val & 0x00000001) {
1804                                 adapter->io_rid = rid;
1805                                 break;
1806                         }
1807                         rid += 4;
1808                 }
1809
1810                 adapter->res_ioport = bus_alloc_resource_any(dev,
1811                                                              SYS_RES_IOPORT,
1812                                                              &adapter->io_rid,
1813                                                              RF_ACTIVE);
1814                 if (!(adapter->res_ioport)) {
1815                         printf("em%d: Unable to allocate bus resource: ioport\n",
1816                                adapter->unit);
1817                         return(ENXIO);
1818                 }
1819
1820                 adapter->hw.io_base =
1821                 rman_get_start(adapter->res_ioport);
1822         }
1823
1824         rid = 0x0;
1825         adapter->res_interrupt = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
1826                                                         RF_SHAREABLE |
1827                                                         RF_ACTIVE);
1828         if (!(adapter->res_interrupt)) {
1829                 printf("em%d: Unable to allocate bus resource: interrupt\n",
1830                        adapter->unit);
1831                 return(ENXIO);
1832         }
1833         if (bus_setup_intr(dev, adapter->res_interrupt,
1834                            INTR_TYPE_NET | INTR_MPSAFE,
1835                            (void (*)(void *)) em_intr, adapter,
1836                            &adapter->int_handler_tag)) {
1837                 printf("em%d: Error registering interrupt handler!\n",
1838                        adapter->unit);
1839                 return(ENXIO);
1840         }
1841
1842         adapter->hw.back = &adapter->osdep;
1843
1844         return(0);
1845 }
1846
1847 static void
1848 em_free_pci_resources(struct adapter * adapter)
1849 {
1850         device_t dev = adapter->dev;
1851
1852         if (adapter->res_interrupt != NULL) {
1853                 bus_teardown_intr(dev, adapter->res_interrupt,
1854                                   adapter->int_handler_tag);
1855                 bus_release_resource(dev, SYS_RES_IRQ, 0,
1856                                      adapter->res_interrupt);
1857         }
1858         if (adapter->res_memory != NULL) {
1859                 bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA,
1860                                      adapter->res_memory);
1861         }
1862
1863         if (adapter->res_ioport != NULL) {
1864                 bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid,
1865                                      adapter->res_ioport);
1866         }
1867         return;
1868 }
1869
1870 /*********************************************************************
1871  *
1872  *  Initialize the hardware to a configuration as specified by the
1873  *  adapter structure. The controller is reset, the EEPROM is
1874  *  verified, the MAC address is set, then the shared initialization
1875  *  routines are called.
1876  *
1877  **********************************************************************/
1878 static int
1879 em_hardware_init(struct adapter * adapter)
1880 {
1881         INIT_DEBUGOUT("em_hardware_init: begin");
1882         /* Issue a global reset */
1883         em_reset_hw(&adapter->hw);
1884
1885         /* When hardware is reset, fifo_head is also reset */
1886         adapter->tx_fifo_head = 0;
1887
1888         /* Make sure we have a good EEPROM before we read from it */
1889         if (em_validate_eeprom_checksum(&adapter->hw) < 0) {
1890                 printf("em%d: The EEPROM Checksum Is Not Valid\n",
1891                        adapter->unit);
1892                 return(EIO);
1893         }
1894
1895         if (em_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) {
1896                 printf("em%d: EEPROM read error while reading part number\n",
1897                        adapter->unit);
1898                 return(EIO);
1899         }
1900
1901         if (em_init_hw(&adapter->hw) < 0) {
1902                 printf("em%d: Hardware Initialization Failed",
1903                        adapter->unit);
1904                 return(EIO);
1905         }
1906
1907         em_check_for_link(&adapter->hw);
1908         if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU)
1909                 adapter->link_active = 1;
1910         else
1911                 adapter->link_active = 0;
1912
1913         if (adapter->link_active) {
1914                 em_get_speed_and_duplex(&adapter->hw,
1915                                         &adapter->link_speed,
1916                                         &adapter->link_duplex);
1917         } else {
1918                 adapter->link_speed = 0;
1919                 adapter->link_duplex = 0;
1920         }
1921
1922         return(0);
1923 }
1924
1925 /*********************************************************************
1926  *
1927  *  Setup networking device structure and register an interface.
1928  *
1929  **********************************************************************/
1930 static void
1931 em_setup_interface(device_t dev, struct adapter * adapter)
1932 {
1933         struct ifnet   *ifp;
1934         INIT_DEBUGOUT("em_setup_interface: begin");
1935
1936         ifp = adapter->ifp = if_alloc(IFT_ETHER);
1937         if (ifp == NULL)
1938                 panic("%s: can not if_alloc()", device_get_nameunit(dev));
1939         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
1940         ifp->if_mtu = ETHERMTU;
1941         ifp->if_baudrate = 1000000000;
1942         ifp->if_init =  em_init;
1943         ifp->if_softc = adapter;
1944         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1945         ifp->if_ioctl = em_ioctl;
1946         ifp->if_start = em_start;
1947         ifp->if_watchdog = em_watchdog;
1948         IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 1);
1949         ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 1;
1950         IFQ_SET_READY(&ifp->if_snd);
1951
1952 #if __FreeBSD_version < 500000
1953         ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
1954 #else
1955         ether_ifattach(ifp, adapter->hw.mac_addr);
1956 #endif
1957
1958         ifp->if_capabilities = ifp->if_capenable = 0;
1959
1960         if (adapter->hw.mac_type >= em_82543) {
1961                 ifp->if_capabilities |= IFCAP_HWCSUM;
1962                 ifp->if_capenable |= IFCAP_HWCSUM;
1963         }
1964
1965         /*
1966          * Tell the upper layer(s) we support long frames.
1967          */
1968         ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
1969 #if __FreeBSD_version >= 500000
1970         ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
1971         ifp->if_capenable |= IFCAP_VLAN_MTU;
1972 #endif
1973
1974 #ifdef DEVICE_POLLING
1975         ifp->if_capabilities |= IFCAP_POLLING;
1976         ifp->if_capenable |= IFCAP_POLLING;
1977 #endif
1978
1979         /*
1980          * Specify the media types supported by this adapter and register
1981          * callbacks to update media and link information
1982          */
1983         ifmedia_init(&adapter->media, IFM_IMASK, em_media_change,
1984                      em_media_status);
1985         if (adapter->hw.media_type == em_media_type_fiber) {
1986                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX,
1987                             0, NULL);
1988                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX,
1989                             0, NULL);
1990         } else {
1991                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL);
1992                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX,
1993                             0, NULL);
1994                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX,
1995                             0, NULL);
1996                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX,
1997                             0, NULL);
1998 #if __FreeBSD_version < 500000
1999                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX,
2000                             0, NULL);
2001                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL);
2002 #else
2003                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX,
2004                             0, NULL);
2005                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL);
2006 #endif
2007         }
2008         ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL);
2009         ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO);
2010
2011         return;
2012 }
2013
2014
2015 /*********************************************************************
2016  *
2017  *  Workaround for SmartSpeed on 82541 and 82547 controllers
2018  *
2019  **********************************************************************/
2020 static void
2021 em_smartspeed(struct adapter *adapter)
2022 {
2023         uint16_t phy_tmp;
2024
2025         if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) ||
2026            !adapter->hw.autoneg || !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
2027                 return;
2028
2029         if(adapter->smartspeed == 0) {
2030                 /* If Master/Slave config fault is asserted twice,
2031                  * we assume back-to-back */
2032                 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp);
2033                 if(!(phy_tmp & SR_1000T_MS_CONFIG_FAULT)) return;
2034                 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp);
2035                 if(phy_tmp & SR_1000T_MS_CONFIG_FAULT) {
2036                         em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL,
2037                                         &phy_tmp);
2038                         if(phy_tmp & CR_1000T_MS_ENABLE) {
2039                                 phy_tmp &= ~CR_1000T_MS_ENABLE;
2040                                 em_write_phy_reg(&adapter->hw,
2041                                                     PHY_1000T_CTRL, phy_tmp);
2042                                 adapter->smartspeed++;
2043                                 if(adapter->hw.autoneg &&
2044                                    !em_phy_setup_autoneg(&adapter->hw) &&
2045                                    !em_read_phy_reg(&adapter->hw, PHY_CTRL,
2046                                                        &phy_tmp)) {
2047                                         phy_tmp |= (MII_CR_AUTO_NEG_EN |
2048                                                     MII_CR_RESTART_AUTO_NEG);
2049                                         em_write_phy_reg(&adapter->hw,
2050                                                          PHY_CTRL, phy_tmp);
2051                                 }
2052                         }
2053                 }
2054                 return;
2055         } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) {
2056                 /* If still no link, perhaps using 2/3 pair cable */
2057                 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp);
2058                 phy_tmp |= CR_1000T_MS_ENABLE;
2059                 em_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp);
2060                 if(adapter->hw.autoneg &&
2061                    !em_phy_setup_autoneg(&adapter->hw) &&
2062                    !em_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_tmp)) {
2063                         phy_tmp |= (MII_CR_AUTO_NEG_EN |
2064                                     MII_CR_RESTART_AUTO_NEG);
2065                         em_write_phy_reg(&adapter->hw, PHY_CTRL, phy_tmp);
2066                 }
2067         }
2068         /* Restart process after EM_SMARTSPEED_MAX iterations */
2069         if(adapter->smartspeed++ == EM_SMARTSPEED_MAX)
2070                 adapter->smartspeed = 0;
2071
2072         return;
2073 }
2074
2075
2076 /*
2077  * Manage DMA'able memory.
2078  */
2079 static void
2080 em_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
2081 {
2082         if (error)
2083                 return;
2084         *(bus_addr_t*) arg = segs->ds_addr;
2085         return;
2086 }
2087
2088 static int
2089 em_dma_malloc(struct adapter *adapter, bus_size_t size,
2090         struct em_dma_alloc *dma, int mapflags)
2091 {
2092         int r;
2093
2094         r = bus_dma_tag_create(NULL,                    /* parent */
2095                                PAGE_SIZE, 0,            /* alignment, bounds */
2096                                BUS_SPACE_MAXADDR,       /* lowaddr */
2097                                BUS_SPACE_MAXADDR,       /* highaddr */
2098                                NULL, NULL,              /* filter, filterarg */
2099                                size,                    /* maxsize */
2100                                1,                       /* nsegments */
2101                                size,                    /* maxsegsize */
2102                                BUS_DMA_ALLOCNOW,        /* flags */
2103                                NULL,                    /* lockfunc */
2104                                NULL,                    /* lockarg */
2105                                &dma->dma_tag);
2106         if (r != 0) {
2107                 printf("em%d: em_dma_malloc: bus_dma_tag_create failed; "
2108                         "error %u\n", adapter->unit, r);
2109                 goto fail_0;
2110         }
2111
2112         r = bus_dmamem_alloc(dma->dma_tag, (void**) &dma->dma_vaddr,
2113                              BUS_DMA_NOWAIT, &dma->dma_map);
2114         if (r != 0) {
2115                 printf("em%d: em_dma_malloc: bus_dmammem_alloc failed; "
2116                         "size %ju, error %d\n", adapter->unit,
2117                         (uintmax_t)size, r);
2118                 goto fail_2;
2119         }
2120
2121         r = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr,
2122                             size,
2123                             em_dmamap_cb,
2124                             &dma->dma_paddr,
2125                             mapflags | BUS_DMA_NOWAIT);
2126         if (r != 0) {
2127                 printf("em%d: em_dma_malloc: bus_dmamap_load failed; "
2128                         "error %u\n", adapter->unit, r);
2129                 goto fail_3;
2130         }
2131
2132         dma->dma_size = size;
2133         return (0);
2134
2135 fail_3:
2136         bus_dmamap_unload(dma->dma_tag, dma->dma_map);
2137 fail_2:
2138         bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map);
2139         bus_dma_tag_destroy(dma->dma_tag);
2140 fail_0:
2141         dma->dma_map = NULL;
2142         dma->dma_tag = NULL;
2143         return (r);
2144 }
2145
2146 static void
2147 em_dma_free(struct adapter *adapter, struct em_dma_alloc *dma)
2148 {
2149         bus_dmamap_unload(dma->dma_tag, dma->dma_map);
2150         bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map);
2151         bus_dma_tag_destroy(dma->dma_tag);
2152 }
2153
2154
2155 /*********************************************************************
2156  *
2157  *  Allocate memory for tx_buffer structures. The tx_buffer stores all
2158  *  the information needed to transmit a packet on the wire.
2159  *
2160  **********************************************************************/
2161 static int
2162 em_allocate_transmit_structures(struct adapter * adapter)
2163 {
2164         if (!(adapter->tx_buffer_area =
2165               (struct em_buffer *) malloc(sizeof(struct em_buffer) *
2166                                              adapter->num_tx_desc, M_DEVBUF,
2167                                              M_NOWAIT))) {
2168                 printf("em%d: Unable to allocate tx_buffer memory\n",
2169                        adapter->unit);
2170                 return ENOMEM;
2171         }
2172
2173         bzero(adapter->tx_buffer_area,
2174               sizeof(struct em_buffer) * adapter->num_tx_desc);
2175
2176         return 0;
2177 }
2178
2179 /*********************************************************************
2180  *
2181  *  Allocate and initialize transmit structures.
2182  *
2183  **********************************************************************/
2184 static int
2185 em_setup_transmit_structures(struct adapter * adapter)
2186 {
2187         /*
2188          * Setup DMA descriptor areas.
2189          */
2190         if (bus_dma_tag_create(NULL,                    /* parent */
2191                                1, 0,                    /* alignment, bounds */
2192                                BUS_SPACE_MAXADDR,       /* lowaddr */
2193                                BUS_SPACE_MAXADDR,       /* highaddr */
2194                                NULL, NULL,              /* filter, filterarg */
2195                                MCLBYTES * 8,            /* maxsize */
2196                                EM_MAX_SCATTER,          /* nsegments */
2197                                MCLBYTES * 8,            /* maxsegsize */
2198                                BUS_DMA_ALLOCNOW,        /* flags */
2199                                NULL,                    /* lockfunc */
2200                                NULL,                    /* lockarg */
2201                                &adapter->txtag)) {
2202                 printf("em%d: Unable to allocate TX DMA tag\n", adapter->unit);
2203                 return (ENOMEM);
2204         }
2205
2206         if (em_allocate_transmit_structures(adapter))
2207                 return (ENOMEM);
2208
2209         bzero((void *) adapter->tx_desc_base,
2210               (sizeof(struct em_tx_desc)) * adapter->num_tx_desc);
2211
2212         adapter->next_avail_tx_desc = 0;
2213         adapter->oldest_used_tx_desc = 0;
2214
2215         /* Set number of descriptors available */
2216         adapter->num_tx_desc_avail = adapter->num_tx_desc;
2217
2218         /* Set checksum context */
2219         adapter->active_checksum_context = OFFLOAD_NONE;
2220
2221         return (0);
2222 }
2223
2224 /*********************************************************************
2225  *
2226  *  Enable transmit unit.
2227  *
2228  **********************************************************************/
2229 static void
2230 em_initialize_transmit_unit(struct adapter * adapter)
2231 {
2232         u_int32_t       reg_tctl;
2233         u_int32_t       reg_tipg = 0;
2234         u_int64_t       bus_addr;
2235
2236          INIT_DEBUGOUT("em_initialize_transmit_unit: begin");
2237         /* Setup the Base and Length of the Tx Descriptor Ring */
2238         bus_addr = adapter->txdma.dma_paddr;
2239         E1000_WRITE_REG(&adapter->hw, TDBAL, (u_int32_t)bus_addr);
2240         E1000_WRITE_REG(&adapter->hw, TDBAH, (u_int32_t)(bus_addr >> 32));
2241         E1000_WRITE_REG(&adapter->hw, TDLEN,
2242                         adapter->num_tx_desc *
2243                         sizeof(struct em_tx_desc));
2244
2245         /* Setup the HW Tx Head and Tail descriptor pointers */
2246         E1000_WRITE_REG(&adapter->hw, TDH, 0);
2247         E1000_WRITE_REG(&adapter->hw, TDT, 0);
2248
2249
2250         HW_DEBUGOUT2("Base = %x, Length = %x\n",
2251                      E1000_READ_REG(&adapter->hw, TDBAL),
2252                      E1000_READ_REG(&adapter->hw, TDLEN));
2253
2254         /* Set the default values for the Tx Inter Packet Gap timer */
2255         switch (adapter->hw.mac_type) {
2256         case em_82542_rev2_0:
2257         case em_82542_rev2_1:
2258                 reg_tipg = DEFAULT_82542_TIPG_IPGT;
2259                 reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
2260                 reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
2261                 break;
2262         default:
2263                 if (adapter->hw.media_type == em_media_type_fiber)
2264                         reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
2265                 else
2266                         reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
2267                 reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
2268                 reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
2269         }
2270
2271         E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg);
2272         E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay.value);
2273         if(adapter->hw.mac_type >= em_82540)
2274                 E1000_WRITE_REG(&adapter->hw, TADV,
2275                     adapter->tx_abs_int_delay.value);
2276
2277         /* Program the Transmit Control Register */
2278         reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN |
2279                    (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
2280         if (adapter->hw.mac_type >= em_82573)
2281                 reg_tctl |= E1000_TCTL_MULR;
2282         if (adapter->link_duplex == 1) {
2283                 reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
2284         } else {
2285                 reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
2286         }
2287         E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl);
2288
2289         /* Setup Transmit Descriptor Settings for this adapter */
2290         adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS;
2291
2292         if (adapter->tx_int_delay.value > 0)
2293                 adapter->txd_cmd |= E1000_TXD_CMD_IDE;
2294
2295         return;
2296 }
2297
2298 /*********************************************************************
2299  *
2300  *  Free all transmit related data structures.
2301  *
2302  **********************************************************************/
2303 static void
2304 em_free_transmit_structures(struct adapter * adapter)
2305 {
2306         struct em_buffer   *tx_buffer;
2307         int             i;
2308
2309         INIT_DEBUGOUT("free_transmit_structures: begin");
2310
2311         if (adapter->tx_buffer_area != NULL) {
2312                 tx_buffer = adapter->tx_buffer_area;
2313                 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) {
2314                         if (tx_buffer->m_head != NULL) {
2315                                 bus_dmamap_unload(adapter->txtag, tx_buffer->map);
2316                                 bus_dmamap_destroy(adapter->txtag, tx_buffer->map);
2317                                 m_freem(tx_buffer->m_head);
2318                         }
2319                         tx_buffer->m_head = NULL;
2320                 }
2321         }
2322         if (adapter->tx_buffer_area != NULL) {
2323                 free(adapter->tx_buffer_area, M_DEVBUF);
2324                 adapter->tx_buffer_area = NULL;
2325         }
2326         if (adapter->txtag != NULL) {
2327                 bus_dma_tag_destroy(adapter->txtag);
2328                 adapter->txtag = NULL;
2329         }
2330         return;
2331 }
2332
2333 /*********************************************************************
2334  *
2335  *  The offload context needs to be set when we transfer the first
2336  *  packet of a particular protocol (TCP/UDP). We change the
2337  *  context only if the protocol type changes.
2338  *
2339  **********************************************************************/
2340 static void
2341 em_transmit_checksum_setup(struct adapter * adapter,
2342                            struct mbuf *mp,
2343                            u_int32_t *txd_upper,
2344                            u_int32_t *txd_lower)
2345 {
2346         struct em_context_desc *TXD;
2347         struct em_buffer *tx_buffer;
2348         int curr_txd;
2349
2350         if (mp->m_pkthdr.csum_flags) {
2351
2352                 if (mp->m_pkthdr.csum_flags & CSUM_TCP) {
2353                         *txd_upper = E1000_TXD_POPTS_TXSM << 8;
2354                         *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
2355                         if (adapter->active_checksum_context == OFFLOAD_TCP_IP)
2356                                 return;
2357                         else
2358                                 adapter->active_checksum_context = OFFLOAD_TCP_IP;
2359
2360                 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) {
2361                         *txd_upper = E1000_TXD_POPTS_TXSM << 8;
2362                         *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
2363                         if (adapter->active_checksum_context == OFFLOAD_UDP_IP)
2364                                 return;
2365                         else
2366                                 adapter->active_checksum_context = OFFLOAD_UDP_IP;
2367                 } else {
2368                         *txd_upper = 0;
2369                         *txd_lower = 0;
2370                         return;
2371                 }
2372         } else {
2373                 *txd_upper = 0;
2374                 *txd_lower = 0;
2375                 return;
2376         }
2377
2378         /* If we reach this point, the checksum offload context
2379          * needs to be reset.
2380          */
2381         curr_txd = adapter->next_avail_tx_desc;
2382         tx_buffer = &adapter->tx_buffer_area[curr_txd];
2383         TXD = (struct em_context_desc *) &adapter->tx_desc_base[curr_txd];
2384
2385         TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN;
2386         TXD->lower_setup.ip_fields.ipcso =
2387                 ETHER_HDR_LEN + offsetof(struct ip, ip_sum);
2388         TXD->lower_setup.ip_fields.ipcse =
2389                 htole16(ETHER_HDR_LEN + sizeof(struct ip) - 1);
2390
2391         TXD->upper_setup.tcp_fields.tucss =
2392                 ETHER_HDR_LEN + sizeof(struct ip);
2393         TXD->upper_setup.tcp_fields.tucse = htole16(0);
2394
2395         if (adapter->active_checksum_context == OFFLOAD_TCP_IP) {
2396                 TXD->upper_setup.tcp_fields.tucso =
2397                         ETHER_HDR_LEN + sizeof(struct ip) +
2398                         offsetof(struct tcphdr, th_sum);
2399         } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) {
2400                 TXD->upper_setup.tcp_fields.tucso =
2401                         ETHER_HDR_LEN + sizeof(struct ip) +
2402                         offsetof(struct udphdr, uh_sum);
2403         }
2404
2405         TXD->tcp_seg_setup.data = htole32(0);
2406         TXD->cmd_and_length = htole32(adapter->txd_cmd | E1000_TXD_CMD_DEXT);
2407
2408         tx_buffer->m_head = NULL;
2409
2410         if (++curr_txd == adapter->num_tx_desc)
2411                 curr_txd = 0;
2412
2413         adapter->num_tx_desc_avail--;
2414         adapter->next_avail_tx_desc = curr_txd;
2415
2416         return;
2417 }
2418
2419 /**********************************************************************
2420  *
2421  *  Examine each tx_buffer in the used queue. If the hardware is done
2422  *  processing the packet then free associated resources. The
2423  *  tx_buffer is put back on the free queue.
2424  *
2425  **********************************************************************/
2426 static void
2427 em_clean_transmit_interrupts(struct adapter * adapter)
2428 {
2429         int i, num_avail;
2430         struct em_buffer *tx_buffer;
2431         struct em_tx_desc   *tx_desc;
2432         struct ifnet   *ifp = adapter->ifp;
2433
2434         mtx_assert(&adapter->mtx, MA_OWNED);
2435
2436         if (adapter->num_tx_desc_avail == adapter->num_tx_desc)
2437                 return;
2438
2439         num_avail = adapter->num_tx_desc_avail;
2440         i = adapter->oldest_used_tx_desc;
2441
2442         tx_buffer = &adapter->tx_buffer_area[i];
2443         tx_desc = &adapter->tx_desc_base[i];
2444
2445         bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
2446             BUS_DMASYNC_POSTREAD);
2447         while (tx_desc->upper.fields.status & E1000_TXD_STAT_DD) {
2448
2449                 tx_desc->upper.data = 0;
2450                 num_avail++;
2451
2452                 if (tx_buffer->m_head) {
2453                         ifp->if_opackets++;
2454                         bus_dmamap_unload(adapter->txtag, tx_buffer->map);
2455                         bus_dmamap_destroy(adapter->txtag, tx_buffer->map);
2456
2457                         m_freem(tx_buffer->m_head);
2458                         tx_buffer->m_head = NULL;
2459                 }
2460
2461                 if (++i == adapter->num_tx_desc)
2462                         i = 0;
2463
2464                 tx_buffer = &adapter->tx_buffer_area[i];
2465                 tx_desc = &adapter->tx_desc_base[i];
2466         }
2467         bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
2468             BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2469
2470         adapter->oldest_used_tx_desc = i;
2471
2472         /*
2473          * If we have enough room, clear IFF_DRV_OACTIVE to tell the stack
2474          * that it is OK to send packets.
2475          * If there are no pending descriptors, clear the timeout. Otherwise,
2476          * if some descriptors have been freed, restart the timeout.
2477          */
2478         if (num_avail > EM_TX_CLEANUP_THRESHOLD) {
2479                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
2480                 if (num_avail == adapter->num_tx_desc)
2481                         ifp->if_timer = 0;
2482                 else if (num_avail == adapter->num_tx_desc_avail)
2483                         ifp->if_timer = EM_TX_TIMEOUT;
2484         }
2485         adapter->num_tx_desc_avail = num_avail;
2486         return;
2487 }
2488
2489 /*********************************************************************
2490  *
2491  *  Get a buffer from system mbuf buffer pool.
2492  *
2493  **********************************************************************/
2494 static int
2495 em_get_buf(int i, struct adapter *adapter,
2496            struct mbuf *nmp)
2497 {
2498         register struct mbuf    *mp = nmp;
2499         struct em_buffer *rx_buffer;
2500         struct ifnet   *ifp;
2501         bus_addr_t paddr;
2502         int error;
2503
2504         ifp = adapter->ifp;
2505
2506         if (mp == NULL) {
2507                 mp = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
2508                 if (mp == NULL) {
2509                         adapter->mbuf_cluster_failed++;
2510                         return(ENOBUFS);
2511                 }
2512                 mp->m_len = mp->m_pkthdr.len = MCLBYTES;
2513         } else {
2514                 mp->m_len = mp->m_pkthdr.len = MCLBYTES;
2515                 mp->m_data = mp->m_ext.ext_buf;
2516                 mp->m_next = NULL;
2517         }
2518
2519         if (ifp->if_mtu <= ETHERMTU) {
2520                 m_adj(mp, ETHER_ALIGN);
2521         }
2522
2523         rx_buffer = &adapter->rx_buffer_area[i];
2524
2525         /*
2526          * Using memory from the mbuf cluster pool, invoke the
2527          * bus_dma machinery to arrange the memory mapping.
2528          */
2529         error = bus_dmamap_load(adapter->rxtag, rx_buffer->map,
2530                                 mtod(mp, void *), mp->m_len,
2531                                 em_dmamap_cb, &paddr, 0);
2532         if (error) {
2533                 m_free(mp);
2534                 return(error);
2535         }
2536         rx_buffer->m_head = mp;
2537         adapter->rx_desc_base[i].buffer_addr = htole64(paddr);
2538         bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD);
2539
2540         return(0);
2541 }
2542
2543 /*********************************************************************
2544  *
2545  *  Allocate memory for rx_buffer structures. Since we use one
2546  *  rx_buffer per received packet, the maximum number of rx_buffer's
2547  *  that we'll need is equal to the number of receive descriptors
2548  *  that we've allocated.
2549  *
2550  **********************************************************************/
2551 static int
2552 em_allocate_receive_structures(struct adapter * adapter)
2553 {
2554         int             i, error;
2555         struct em_buffer *rx_buffer;
2556
2557         if (!(adapter->rx_buffer_area =
2558               (struct em_buffer *) malloc(sizeof(struct em_buffer) *
2559                                           adapter->num_rx_desc, M_DEVBUF,
2560                                           M_NOWAIT))) {
2561                 printf("em%d: Unable to allocate rx_buffer memory\n",
2562                        adapter->unit);
2563                 return(ENOMEM);
2564         }
2565
2566         bzero(adapter->rx_buffer_area,
2567               sizeof(struct em_buffer) * adapter->num_rx_desc);
2568
2569         error = bus_dma_tag_create(NULL,                /* parent */
2570                                1, 0,                    /* alignment, bounds */
2571                                BUS_SPACE_MAXADDR,       /* lowaddr */
2572                                BUS_SPACE_MAXADDR,       /* highaddr */
2573                                NULL, NULL,              /* filter, filterarg */
2574                                MCLBYTES,                /* maxsize */
2575                                1,                       /* nsegments */
2576                                MCLBYTES,                /* maxsegsize */
2577                                BUS_DMA_ALLOCNOW,        /* flags */
2578                                NULL,                    /* lockfunc */
2579                                NULL,                    /* lockarg */
2580                                &adapter->rxtag);
2581         if (error != 0) {
2582                 printf("em%d: em_allocate_receive_structures: "
2583                         "bus_dma_tag_create failed; error %u\n",
2584                        adapter->unit, error);
2585                 goto fail_0;
2586         }
2587
2588         rx_buffer = adapter->rx_buffer_area;
2589         for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
2590                 error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT,
2591                                           &rx_buffer->map);
2592                 if (error != 0) {
2593                         printf("em%d: em_allocate_receive_structures: "
2594                                 "bus_dmamap_create failed; error %u\n",
2595                                 adapter->unit, error);
2596                         goto fail_1;
2597                 }
2598         }
2599
2600         for (i = 0; i < adapter->num_rx_desc; i++) {
2601                 error = em_get_buf(i, adapter, NULL);
2602                 if (error != 0) {
2603                         adapter->rx_buffer_area[i].m_head = NULL;
2604                         adapter->rx_desc_base[i].buffer_addr = 0;
2605                         return(error);
2606                 }
2607         }
2608         bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
2609             BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2610
2611         return(0);
2612
2613 fail_1:
2614         bus_dma_tag_destroy(adapter->rxtag);
2615 fail_0:
2616         adapter->rxtag = NULL;
2617         free(adapter->rx_buffer_area, M_DEVBUF);
2618         adapter->rx_buffer_area = NULL;
2619         return (error);
2620 }
2621
2622 /*********************************************************************
2623  *
2624  *  Allocate and initialize receive structures.
2625  *
2626  **********************************************************************/
2627 static int
2628 em_setup_receive_structures(struct adapter * adapter)
2629 {
2630         bzero((void *) adapter->rx_desc_base,
2631               (sizeof(struct em_rx_desc)) * adapter->num_rx_desc);
2632
2633         if (em_allocate_receive_structures(adapter))
2634                 return ENOMEM;
2635
2636         /* Setup our descriptor pointers */
2637         adapter->next_rx_desc_to_check = 0;
2638         return(0);
2639 }
2640
2641 /*********************************************************************
2642  *
2643  *  Enable receive unit.
2644  *
2645  **********************************************************************/
2646 static void
2647 em_initialize_receive_unit(struct adapter * adapter)
2648 {
2649         u_int32_t       reg_rctl;
2650         u_int32_t       reg_rxcsum;
2651         struct ifnet    *ifp;
2652         u_int64_t       bus_addr;
2653
2654         INIT_DEBUGOUT("em_initialize_receive_unit: begin");
2655         ifp = adapter->ifp;
2656
2657         /* Make sure receives are disabled while setting up the descriptor ring */
2658         E1000_WRITE_REG(&adapter->hw, RCTL, 0);
2659
2660         /* Set the Receive Delay Timer Register */
2661         E1000_WRITE_REG(&adapter->hw, RDTR,
2662                         adapter->rx_int_delay.value | E1000_RDT_FPDB);
2663
2664         if(adapter->hw.mac_type >= em_82540) {
2665                 E1000_WRITE_REG(&adapter->hw, RADV,
2666                     adapter->rx_abs_int_delay.value);
2667
2668                 /* Set the interrupt throttling rate.  Value is calculated
2669                  * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */
2670 #define MAX_INTS_PER_SEC        8000
2671 #define DEFAULT_ITR             1000000000/(MAX_INTS_PER_SEC * 256)
2672                 E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR);
2673         }
2674
2675         /* Setup the Base and Length of the Rx Descriptor Ring */
2676         bus_addr = adapter->rxdma.dma_paddr;
2677         E1000_WRITE_REG(&adapter->hw, RDBAL, (u_int32_t)bus_addr);
2678         E1000_WRITE_REG(&adapter->hw, RDBAH, (u_int32_t)(bus_addr >> 32));
2679         E1000_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc *
2680                         sizeof(struct em_rx_desc));
2681
2682         /* Setup the HW Rx Head and Tail Descriptor Pointers */
2683         E1000_WRITE_REG(&adapter->hw, RDH, 0);
2684         E1000_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1);
2685
2686         /* Setup the Receive Control Register */
2687         reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
2688                    E1000_RCTL_RDMTS_HALF |
2689                    (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT);
2690
2691         if (adapter->hw.tbi_compatibility_on == TRUE)
2692                 reg_rctl |= E1000_RCTL_SBP;
2693
2694
2695         switch (adapter->rx_buffer_len) {
2696         default:
2697         case EM_RXBUFFER_2048:
2698                 reg_rctl |= E1000_RCTL_SZ_2048;
2699                 break;
2700         case EM_RXBUFFER_4096:
2701                 reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
2702                 break;
2703         case EM_RXBUFFER_8192:
2704                 reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
2705                 break;
2706         case EM_RXBUFFER_16384:
2707                 reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
2708                 break;
2709         }
2710
2711         if (ifp->if_mtu > ETHERMTU)
2712                 reg_rctl |= E1000_RCTL_LPE;
2713
2714         /* Enable 82543 Receive Checksum Offload for TCP and UDP */
2715         if ((adapter->hw.mac_type >= em_82543) &&
2716             (ifp->if_capenable & IFCAP_RXCSUM)) {
2717                 reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM);
2718                 reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL);
2719                 E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum);
2720         }
2721
2722         /* Enable Receives */
2723         E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
2724
2725         return;
2726 }
2727
2728 /*********************************************************************
2729  *
2730  *  Free receive related data structures.
2731  *
2732  **********************************************************************/
2733 static void
2734 em_free_receive_structures(struct adapter *adapter)
2735 {
2736         struct em_buffer   *rx_buffer;
2737         int             i;
2738
2739         INIT_DEBUGOUT("free_receive_structures: begin");
2740
2741         if (adapter->rx_buffer_area != NULL) {
2742                 rx_buffer = adapter->rx_buffer_area;
2743                 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
2744                         if (rx_buffer->map != NULL) {
2745                                 bus_dmamap_unload(adapter->rxtag, rx_buffer->map);
2746                                 bus_dmamap_destroy(adapter->rxtag, rx_buffer->map);
2747                         }
2748                         if (rx_buffer->m_head != NULL)
2749                                 m_freem(rx_buffer->m_head);
2750                         rx_buffer->m_head = NULL;
2751                 }
2752         }
2753         if (adapter->rx_buffer_area != NULL) {
2754                 free(adapter->rx_buffer_area, M_DEVBUF);
2755                 adapter->rx_buffer_area = NULL;
2756         }
2757         if (adapter->rxtag != NULL) {
2758                 bus_dma_tag_destroy(adapter->rxtag);
2759                 adapter->rxtag = NULL;
2760         }
2761         return;
2762 }
2763
2764 /*********************************************************************
2765  *
2766  *  This routine executes in interrupt context. It replenishes
2767  *  the mbufs in the descriptor and sends data which has been
2768  *  dma'ed into host memory to upper layer.
2769  *
2770  *  We loop at most count times if count is > 0, or until done if
2771  *  count < 0.
2772  *
2773  *********************************************************************/
2774 static void
2775 em_process_receive_interrupts(struct adapter * adapter, int count)
2776 {
2777         struct ifnet        *ifp;
2778         struct mbuf         *mp;
2779 #if __FreeBSD_version < 500000
2780         struct ether_header *eh;
2781 #endif
2782         u_int8_t            accept_frame = 0;
2783         u_int8_t            eop = 0;
2784         u_int16_t           len, desc_len, prev_len_adj;
2785         int                 i;
2786
2787         /* Pointer to the receive descriptor being examined. */
2788         struct em_rx_desc   *current_desc;
2789
2790         mtx_assert(&adapter->mtx, MA_OWNED);
2791
2792         ifp = adapter->ifp;
2793         i = adapter->next_rx_desc_to_check;
2794         current_desc = &adapter->rx_desc_base[i];
2795         bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
2796             BUS_DMASYNC_POSTREAD);
2797
2798         if (!((current_desc->status) & E1000_RXD_STAT_DD)) {
2799                 return;
2800         }
2801
2802         while ((current_desc->status & E1000_RXD_STAT_DD) && (count != 0)) {
2803
2804                 mp = adapter->rx_buffer_area[i].m_head;
2805                 bus_dmamap_sync(adapter->rxtag, adapter->rx_buffer_area[i].map,
2806                                 BUS_DMASYNC_POSTREAD);
2807
2808                 accept_frame = 1;
2809                 prev_len_adj = 0;
2810                 desc_len = le16toh(current_desc->length);
2811                 if (current_desc->status & E1000_RXD_STAT_EOP) {
2812                         count--;
2813                         eop = 1;
2814                         if (desc_len < ETHER_CRC_LEN) {
2815                                 len = 0;
2816                                 prev_len_adj = ETHER_CRC_LEN - desc_len;
2817                         }
2818                         else {
2819                                 len = desc_len - ETHER_CRC_LEN;
2820                         }
2821                 } else {
2822                         eop = 0;
2823                         len = desc_len;
2824                 }
2825
2826                 if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
2827                         u_int8_t            last_byte;
2828                         u_int32_t           pkt_len = desc_len;
2829
2830                         if (adapter->fmp != NULL)
2831                                 pkt_len += adapter->fmp->m_pkthdr.len;
2832
2833                         last_byte = *(mtod(mp, caddr_t) + desc_len - 1);
2834
2835                         if (TBI_ACCEPT(&adapter->hw, current_desc->status,
2836                                        current_desc->errors,
2837                                        pkt_len, last_byte)) {
2838                                 em_tbi_adjust_stats(&adapter->hw,
2839                                                     &adapter->stats,
2840                                                     pkt_len,
2841                                                     adapter->hw.mac_addr);
2842                                 if (len > 0) len--;
2843                         }
2844                         else {
2845                                 accept_frame = 0;
2846                         }
2847                 }
2848
2849                 if (accept_frame) {
2850
2851                         if (em_get_buf(i, adapter, NULL) == ENOBUFS) {
2852                                 adapter->dropped_pkts++;
2853                                 em_get_buf(i, adapter, mp);
2854                                 if (adapter->fmp != NULL)
2855                                         m_freem(adapter->fmp);
2856                                 adapter->fmp = NULL;
2857                                 adapter->lmp = NULL;
2858                                 break;
2859                         }
2860
2861                         /* Assign correct length to the current fragment */
2862                         mp->m_len = len;
2863
2864                         if (adapter->fmp == NULL) {
2865                                 mp->m_pkthdr.len = len;
2866                                 adapter->fmp = mp;       /* Store the first mbuf */
2867                                 adapter->lmp = mp;
2868                         } else {
2869                                 /* Chain mbuf's together */
2870                                 mp->m_flags &= ~M_PKTHDR;
2871                                 /*
2872                                  * Adjust length of previous mbuf in chain if we
2873                                  * received less than 4 bytes in the last descriptor.
2874                                  */
2875                                 if (prev_len_adj > 0) {
2876                                         adapter->lmp->m_len -= prev_len_adj;
2877                                         adapter->fmp->m_pkthdr.len -= prev_len_adj;
2878                                 }
2879                                 adapter->lmp->m_next = mp;
2880                                 adapter->lmp = adapter->lmp->m_next;
2881                                 adapter->fmp->m_pkthdr.len += len;
2882                         }
2883
2884                         if (eop) {
2885                                 adapter->fmp->m_pkthdr.rcvif = ifp;
2886                                  ifp->if_ipackets++;
2887
2888 #if __FreeBSD_version < 500000
2889                                 eh = mtod(adapter->fmp, struct ether_header *);
2890                                 /* Remove ethernet header from mbuf */
2891                                 m_adj(adapter->fmp, sizeof(struct ether_header));
2892                                 em_receive_checksum(adapter, current_desc,
2893                                                     adapter->fmp);
2894                                 if (current_desc->status & E1000_RXD_STAT_VP)
2895                                         VLAN_INPUT_TAG(eh, adapter->fmp,
2896                                                        (current_desc->special &
2897                                                         E1000_RXD_SPC_VLAN_MASK));
2898                                 else
2899                                         ether_input(ifp, eh, adapter->fmp);
2900 #else
2901
2902                                 em_receive_checksum(adapter, current_desc,
2903                                                     adapter->fmp);
2904                                 if (current_desc->status & E1000_RXD_STAT_VP)
2905                                         VLAN_INPUT_TAG(ifp, adapter->fmp,
2906                                                        (current_desc->special &
2907                                                         E1000_RXD_SPC_VLAN_MASK),
2908                                                        adapter->fmp = NULL);
2909
2910                                 if (adapter->fmp != NULL) {
2911                                         EM_UNLOCK(adapter);
2912                                         (*ifp->if_input)(ifp, adapter->fmp);
2913                                         EM_LOCK(adapter);
2914                                 }
2915 #endif
2916                                 adapter->fmp = NULL;
2917                                 adapter->lmp = NULL;
2918                         }
2919                 } else {
2920                         adapter->dropped_pkts++;
2921                         em_get_buf(i, adapter, mp);
2922                         if (adapter->fmp != NULL)
2923                                 m_freem(adapter->fmp);
2924                         adapter->fmp = NULL;
2925                         adapter->lmp = NULL;
2926                 }
2927
2928                 /* Zero out the receive descriptors status  */
2929                 current_desc->status = 0;
2930
2931                 /* Advance the E1000's Receive Queue #0  "Tail Pointer". */
2932                 E1000_WRITE_REG(&adapter->hw, RDT, i);
2933
2934                 /* Advance our pointers to the next descriptor */
2935                 if (++i == adapter->num_rx_desc) {
2936                         i = 0;
2937                         current_desc = adapter->rx_desc_base;
2938                 } else
2939                         current_desc++;
2940         }
2941         bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map,
2942             BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2943         adapter->next_rx_desc_to_check = i;
2944         return;
2945 }
2946
2947 /*********************************************************************
2948  *
2949  *  Verify that the hardware indicated that the checksum is valid.
2950  *  Inform the stack about the status of checksum so that stack
2951  *  doesn't spend time verifying the checksum.
2952  *
2953  *********************************************************************/
2954 static void
2955 em_receive_checksum(struct adapter *adapter,
2956                     struct em_rx_desc *rx_desc,
2957                     struct mbuf *mp)
2958 {
2959         /* 82543 or newer only */
2960         if ((adapter->hw.mac_type < em_82543) ||
2961             /* Ignore Checksum bit is set */
2962             (rx_desc->status & E1000_RXD_STAT_IXSM)) {
2963                 mp->m_pkthdr.csum_flags = 0;
2964                 return;
2965         }
2966
2967         if (rx_desc->status & E1000_RXD_STAT_IPCS) {
2968                 /* Did it pass? */
2969                 if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) {
2970                         /* IP Checksum Good */
2971                         mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
2972                         mp->m_pkthdr.csum_flags |= CSUM_IP_VALID;
2973
2974                 } else {
2975                         mp->m_pkthdr.csum_flags = 0;
2976                 }
2977         }
2978
2979         if (rx_desc->status & E1000_RXD_STAT_TCPCS) {
2980                 /* Did it pass? */
2981                 if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) {
2982                         mp->m_pkthdr.csum_flags |=
2983                         (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
2984                         mp->m_pkthdr.csum_data = htons(0xffff);
2985                 }
2986         }
2987
2988         return;
2989 }
2990
2991
2992 static void
2993 em_enable_vlans(struct adapter *adapter)
2994 {
2995         uint32_t ctrl;
2996
2997         E1000_WRITE_REG(&adapter->hw, VET, ETHERTYPE_VLAN);
2998
2999         ctrl = E1000_READ_REG(&adapter->hw, CTRL);
3000         ctrl |= E1000_CTRL_VME;
3001         E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
3002
3003         return;
3004 }
3005
3006 static void
3007 em_disable_vlans(struct adapter *adapter)
3008 {
3009         uint32_t ctrl;
3010
3011         ctrl = E1000_READ_REG(&adapter->hw, CTRL);
3012         ctrl &= ~E1000_CTRL_VME;
3013         E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
3014
3015         return;
3016 }
3017
3018 static void
3019 em_enable_intr(struct adapter * adapter)
3020 {
3021         E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK));
3022         return;
3023 }
3024
3025 static void
3026 em_disable_intr(struct adapter *adapter)
3027 {
3028         /*
3029          * The first version of 82542 had an errata where when link was forced it
3030          * would stay up even up even if the cable was disconnected.  Sequence errors
3031          * were used to detect the disconnect and then the driver would unforce the link.
3032          * This code in the in the ISR.  For this to work correctly the Sequence error
3033          * interrupt had to be enabled all the time.
3034          */
3035
3036         if (adapter->hw.mac_type == em_82542_rev2_0)
3037             E1000_WRITE_REG(&adapter->hw, IMC,
3038                 (0xffffffff & ~E1000_IMC_RXSEQ));
3039         else
3040             E1000_WRITE_REG(&adapter->hw, IMC,
3041                 0xffffffff);
3042         return;
3043 }
3044
3045 static int
3046 em_is_valid_ether_addr(u_int8_t *addr)
3047 {
3048         char zero_addr[6] = { 0, 0, 0, 0, 0, 0 };
3049
3050         if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) {
3051                 return (FALSE);
3052         }
3053
3054         return(TRUE);
3055 }
3056
3057 void
3058 em_write_pci_cfg(struct em_hw *hw,
3059                       uint32_t reg,
3060                       uint16_t *value)
3061 {
3062         pci_write_config(((struct em_osdep *)hw->back)->dev, reg,
3063                          *value, 2);
3064 }
3065
3066 void
3067 em_read_pci_cfg(struct em_hw *hw, uint32_t reg,
3068                      uint16_t *value)
3069 {
3070         *value = pci_read_config(((struct em_osdep *)hw->back)->dev,
3071                                  reg, 2);
3072         return;
3073 }
3074
3075 void
3076 em_pci_set_mwi(struct em_hw *hw)
3077 {
3078         pci_write_config(((struct em_osdep *)hw->back)->dev,
3079                          PCIR_COMMAND,
3080                          (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2);
3081         return;
3082 }
3083
3084 void
3085 em_pci_clear_mwi(struct em_hw *hw)
3086 {
3087         pci_write_config(((struct em_osdep *)hw->back)->dev,
3088                          PCIR_COMMAND,
3089                          (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2);
3090         return;
3091 }
3092
3093 uint32_t
3094 em_io_read(struct em_hw *hw, unsigned long port)
3095 {
3096         return(inl(port));
3097 }
3098
3099 void
3100 em_io_write(struct em_hw *hw, unsigned long port, uint32_t value)
3101 {
3102         outl(port, value);
3103         return;
3104 }
3105
3106 /*********************************************************************
3107 * 82544 Coexistence issue workaround.
3108 *    There are 2 issues.
3109 *       1. Transmit Hang issue.
3110 *    To detect this issue, following equation can be used...
3111 *          SIZE[3:0] + ADDR[2:0] = SUM[3:0].
3112 *          If SUM[3:0] is in between 1 to 4, we will have this issue.
3113 *
3114 *       2. DAC issue.
3115 *    To detect this issue, following equation can be used...
3116 *          SIZE[3:0] + ADDR[2:0] = SUM[3:0].
3117 *          If SUM[3:0] is in between 9 to c, we will have this issue.
3118 *
3119 *
3120 *    WORKAROUND:
3121 *          Make sure we do not have ending address as 1,2,3,4(Hang) or 9,a,b,c (DAC)
3122 *
3123 *** *********************************************************************/
3124 static u_int32_t
3125 em_fill_descriptors (u_int64_t address,
3126                               u_int32_t length,
3127                               PDESC_ARRAY desc_array)
3128 {
3129         /* Since issue is sensitive to length and address.*/
3130         /* Let us first check the address...*/
3131         u_int32_t safe_terminator;
3132         if (length <= 4) {
3133                 desc_array->descriptor[0].address = address;
3134                 desc_array->descriptor[0].length = length;
3135                 desc_array->elements = 1;
3136                 return desc_array->elements;
3137         }
3138         safe_terminator = (u_int32_t)((((u_int32_t)address & 0x7) + (length & 0xF)) & 0xF);
3139         /* if it does not fall between 0x1 to 0x4 and 0x9 to 0xC then return */
3140         if (safe_terminator == 0   ||
3141         (safe_terminator > 4   &&
3142         safe_terminator < 9)   ||
3143         (safe_terminator > 0xC &&
3144         safe_terminator <= 0xF)) {
3145                 desc_array->descriptor[0].address = address;
3146                 desc_array->descriptor[0].length = length;
3147                 desc_array->elements = 1;
3148                 return desc_array->elements;
3149         }
3150
3151         desc_array->descriptor[0].address = address;
3152         desc_array->descriptor[0].length = length - 4;
3153         desc_array->descriptor[1].address = address + (length - 4);
3154         desc_array->descriptor[1].length = 4;
3155         desc_array->elements = 2;
3156         return desc_array->elements;
3157 }
3158
3159 /**********************************************************************
3160  *
3161  *  Update the board statistics counters.
3162  *
3163  **********************************************************************/
3164 static void
3165 em_update_stats_counters(struct adapter *adapter)
3166 {
3167         struct ifnet   *ifp;
3168
3169         if(adapter->hw.media_type == em_media_type_copper ||
3170            (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU)) {
3171                 adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS);
3172                 adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC);
3173         }
3174         adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS);
3175         adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC);
3176         adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC);
3177         adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL);
3178
3179         adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC);
3180         adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL);
3181         adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC);
3182         adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC);
3183         adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC);
3184         adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC);
3185         adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC);
3186         adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC);
3187         adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC);
3188         adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC);
3189         adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64);
3190         adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127);
3191         adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255);
3192         adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511);
3193         adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023);
3194         adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522);
3195         adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC);
3196         adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC);
3197         adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC);
3198         adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC);
3199
3200         /* For the 64-bit byte counters the low dword must be read first. */
3201         /* Both registers clear on the read of the high dword */
3202
3203         adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL);
3204         adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH);
3205         adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL);
3206         adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH);
3207
3208         adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC);
3209         adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC);
3210         adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC);
3211         adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC);
3212         adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC);
3213
3214         adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL);
3215         adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH);
3216         adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL);
3217         adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH);
3218
3219         adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR);
3220         adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT);
3221         adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64);
3222         adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127);
3223         adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255);
3224         adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511);
3225         adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023);
3226         adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522);
3227         adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC);
3228         adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC);
3229
3230         if (adapter->hw.mac_type >= em_82543) {
3231                 adapter->stats.algnerrc +=
3232                 E1000_READ_REG(&adapter->hw, ALGNERRC);
3233                 adapter->stats.rxerrc +=
3234                 E1000_READ_REG(&adapter->hw, RXERRC);
3235                 adapter->stats.tncrs +=
3236                 E1000_READ_REG(&adapter->hw, TNCRS);
3237                 adapter->stats.cexterr +=
3238                 E1000_READ_REG(&adapter->hw, CEXTERR);
3239                 adapter->stats.tsctc +=
3240                 E1000_READ_REG(&adapter->hw, TSCTC);
3241                 adapter->stats.tsctfc +=
3242                 E1000_READ_REG(&adapter->hw, TSCTFC);
3243         }
3244         ifp = adapter->ifp;
3245
3246         /* Fill out the OS statistics structure */
3247         ifp->if_ibytes = adapter->stats.gorcl;
3248         ifp->if_obytes = adapter->stats.gotcl;
3249         ifp->if_imcasts = adapter->stats.mprc;
3250         ifp->if_collisions = adapter->stats.colc;
3251
3252         /* Rx Errors */
3253         ifp->if_ierrors =
3254         adapter->dropped_pkts +
3255         adapter->stats.rxerrc +
3256         adapter->stats.crcerrs +
3257         adapter->stats.algnerrc +
3258         adapter->stats.rlec +
3259         adapter->stats.mpc + adapter->stats.cexterr;
3260
3261         /* Tx Errors */
3262         ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol;
3263
3264 }
3265
3266
3267 /**********************************************************************
3268  *
3269  *  This routine is called only when em_display_debug_stats is enabled.
3270  *  This routine provides a way to take a look at important statistics
3271  *  maintained by the driver and hardware.
3272  *
3273  **********************************************************************/
3274 static void
3275 em_print_debug_info(struct adapter *adapter)
3276 {
3277         int unit = adapter->unit;
3278         uint8_t *hw_addr = adapter->hw.hw_addr;
3279
3280         printf("em%d: Adapter hardware address = %p \n", unit, hw_addr);
3281         printf("em%d:CTRL  = 0x%x\n", unit,
3282                 E1000_READ_REG(&adapter->hw, CTRL));
3283         printf("em%d:RCTL  = 0x%x PS=(0x8402)\n", unit,
3284                 E1000_READ_REG(&adapter->hw, RCTL));
3285         printf("em%d:tx_int_delay = %d, tx_abs_int_delay = %d\n", unit,
3286               E1000_READ_REG(&adapter->hw, TIDV),
3287               E1000_READ_REG(&adapter->hw, TADV));
3288         printf("em%d:rx_int_delay = %d, rx_abs_int_delay = %d\n", unit,
3289               E1000_READ_REG(&adapter->hw, RDTR),
3290               E1000_READ_REG(&adapter->hw, RADV));
3291         printf("em%d: fifo workaround = %lld, fifo_reset = %lld\n", unit,
3292                (long long)adapter->tx_fifo_wrk_cnt,
3293                (long long)adapter->tx_fifo_reset_cnt);
3294         printf("em%d: hw tdh = %d, hw tdt = %d\n", unit,
3295                E1000_READ_REG(&adapter->hw, TDH),
3296                E1000_READ_REG(&adapter->hw, TDT));
3297         printf("em%d: Num Tx descriptors avail = %d\n", unit,
3298                adapter->num_tx_desc_avail);
3299         printf("em%d: Tx Descriptors not avail1 = %ld\n", unit,
3300                adapter->no_tx_desc_avail1);
3301         printf("em%d: Tx Descriptors not avail2 = %ld\n", unit,
3302                adapter->no_tx_desc_avail2);
3303         printf("em%d: Std mbuf failed = %ld\n", unit,
3304                adapter->mbuf_alloc_failed);
3305         printf("em%d: Std mbuf cluster failed = %ld\n", unit,
3306                adapter->mbuf_cluster_failed);
3307         printf("em%d: Driver dropped packets = %ld\n", unit,
3308                adapter->dropped_pkts);
3309
3310         return;
3311 }
3312
3313 static void
3314 em_print_hw_stats(struct adapter *adapter)
3315 {
3316         int unit = adapter->unit;
3317
3318         printf("em%d: Excessive collisions = %lld\n", unit,
3319                (long long)adapter->stats.ecol);
3320         printf("em%d: Symbol errors = %lld\n", unit,
3321                (long long)adapter->stats.symerrs);
3322         printf("em%d: Sequence errors = %lld\n", unit,
3323                (long long)adapter->stats.sec);
3324         printf("em%d: Defer count = %lld\n", unit,
3325                (long long)adapter->stats.dc);
3326
3327         printf("em%d: Missed Packets = %lld\n", unit,
3328                (long long)adapter->stats.mpc);
3329         printf("em%d: Receive No Buffers = %lld\n", unit,
3330                (long long)adapter->stats.rnbc);
3331         printf("em%d: Receive length errors = %lld\n", unit,
3332                (long long)adapter->stats.rlec);
3333         printf("em%d: Receive errors = %lld\n", unit,
3334                (long long)adapter->stats.rxerrc);
3335         printf("em%d: Crc errors = %lld\n", unit,
3336                (long long)adapter->stats.crcerrs);
3337         printf("em%d: Alignment errors = %lld\n", unit,
3338                (long long)adapter->stats.algnerrc);
3339         printf("em%d: Carrier extension errors = %lld\n", unit,
3340                (long long)adapter->stats.cexterr);
3341
3342         printf("em%d: XON Rcvd = %lld\n", unit,
3343                (long long)adapter->stats.xonrxc);
3344         printf("em%d: XON Xmtd = %lld\n", unit,
3345                (long long)adapter->stats.xontxc);
3346         printf("em%d: XOFF Rcvd = %lld\n", unit,
3347                (long long)adapter->stats.xoffrxc);
3348         printf("em%d: XOFF Xmtd = %lld\n", unit,
3349                (long long)adapter->stats.xofftxc);
3350
3351         printf("em%d: Good Packets Rcvd = %lld\n", unit,
3352                (long long)adapter->stats.gprc);
3353         printf("em%d: Good Packets Xmtd = %lld\n", unit,
3354                (long long)adapter->stats.gptc);
3355
3356         return;
3357 }
3358
3359 static int
3360 em_sysctl_debug_info(SYSCTL_HANDLER_ARGS)
3361 {
3362         int error;
3363         int result;
3364         struct adapter *adapter;
3365
3366         result = -1;
3367         error = sysctl_handle_int(oidp, &result, 0, req);
3368
3369         if (error || !req->newptr)
3370                 return (error);
3371
3372         if (result == 1) {
3373                 adapter = (struct adapter *)arg1;
3374                 em_print_debug_info(adapter);
3375         }
3376
3377         return error;
3378 }
3379
3380
3381 static int
3382 em_sysctl_stats(SYSCTL_HANDLER_ARGS)
3383 {
3384         int error;
3385         int result;
3386         struct adapter *adapter;
3387
3388         result = -1;
3389         error = sysctl_handle_int(oidp, &result, 0, req);
3390
3391         if (error || !req->newptr)
3392                 return (error);
3393
3394         if (result == 1) {
3395                 adapter = (struct adapter *)arg1;
3396                 em_print_hw_stats(adapter);
3397         }
3398
3399         return error;
3400 }
3401
3402 static int
3403 em_sysctl_int_delay(SYSCTL_HANDLER_ARGS)
3404 {
3405         struct em_int_delay_info *info;
3406         struct adapter *adapter;
3407         u_int32_t regval;
3408         int error;
3409         int usecs;
3410         int ticks;
3411         int s;
3412
3413         info = (struct em_int_delay_info *)arg1;
3414         adapter = info->adapter;
3415         usecs = info->value;
3416         error = sysctl_handle_int(oidp, &usecs, 0, req);
3417         if (error != 0 || req->newptr == NULL)
3418                 return error;
3419         if (usecs < 0 || usecs > E1000_TICKS_TO_USECS(65535))
3420                 return EINVAL;
3421         info->value = usecs;
3422         ticks = E1000_USECS_TO_TICKS(usecs);
3423
3424         s = splimp();
3425         regval = E1000_READ_OFFSET(&adapter->hw, info->offset);
3426         regval = (regval & ~0xffff) | (ticks & 0xffff);
3427         /* Handle a few special cases. */
3428         switch (info->offset) {
3429         case E1000_RDTR:
3430         case E1000_82542_RDTR:
3431                 regval |= E1000_RDT_FPDB;
3432                 break;
3433         case E1000_TIDV:
3434         case E1000_82542_TIDV:
3435                 if (ticks == 0) {
3436                         adapter->txd_cmd &= ~E1000_TXD_CMD_IDE;
3437                         /* Don't write 0 into the TIDV register. */
3438                         regval++;
3439                 } else
3440                         adapter->txd_cmd |= E1000_TXD_CMD_IDE;
3441                 break;
3442         }
3443         E1000_WRITE_OFFSET(&adapter->hw, info->offset, regval);
3444         splx(s);
3445         return 0;
3446 }
3447
3448 static void
3449 em_add_int_delay_sysctl(struct adapter *adapter, const char *name,
3450     const char *description, struct em_int_delay_info *info,
3451     int offset, int value)
3452 {
3453         info->adapter = adapter;
3454         info->offset = offset;
3455         info->value = value;
3456         SYSCTL_ADD_PROC(device_get_sysctl_ctx(adapter->dev),
3457             SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)),
3458             OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW,
3459             info, 0, em_sysctl_int_delay, "I", description);
3460 }