sys/dev/netif/em/if_em.c

   1 /**************************************************************************
   2
   3 Copyright (c) 2001-2003, 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: src/sys/dev/em/if_em.c,v 1.2.2.15 2003/06/09 22:10:15 pdeuskar Exp $*/
  35 /*$DragonFly: src/sys/dev/netif/em/if_em.c,v 1.6 2004/02/13 02:44:47 joerg Exp $*/
  36
  37 #include "if_em.h"
  38
  39 /*********************************************************************
  40  *  Set this to one to display debug statistics
  41  *********************************************************************/
  42 int             em_display_debug_stats = 0;
  43
  44 /*********************************************************************
  45  *  Linked list of board private structures for all NICs found
  46  *********************************************************************/
  47
  48 struct adapter *em_adapter_list = NULL;
  49
  50
  51 /*********************************************************************
  52  *  Driver version
  53  *********************************************************************/
  54
  55 char em_driver_version[] = "1.6.6";
  56
  57
  58 /*********************************************************************
  59  *  PCI Device ID Table
  60  *
  61  *  Used by probe to select devices to load on
  62  *  Last field stores an index into em_strings
  63  *  Last entry must be all 0s
  64  *
  65  *  { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
  66  *********************************************************************/
  67
  68 static em_vendor_info_t em_vendor_info_array[] =
  69 {
  70         /* Intel(R) PRO/1000 Network Connection */
  71         { 0x8086, 0x1000, PCI_ANY_ID, PCI_ANY_ID, 0},
  72         { 0x8086, 0x1001, PCI_ANY_ID, PCI_ANY_ID, 0},
  73         { 0x8086, 0x1004, PCI_ANY_ID, PCI_ANY_ID, 0},
  74         { 0x8086, 0x1008, PCI_ANY_ID, PCI_ANY_ID, 0},
  75         { 0x8086, 0x1009, PCI_ANY_ID, PCI_ANY_ID, 0},
  76         { 0x8086, 0x100C, PCI_ANY_ID, PCI_ANY_ID, 0},
  77         { 0x8086, 0x100D, PCI_ANY_ID, PCI_ANY_ID, 0},
  78         { 0x8086, 0x100E, PCI_ANY_ID, PCI_ANY_ID, 0},
  79         { 0x8086, 0x100F, PCI_ANY_ID, PCI_ANY_ID, 0},
  80         { 0x8086, 0x1010, PCI_ANY_ID, PCI_ANY_ID, 0},
  81         { 0x8086, 0x1011, PCI_ANY_ID, PCI_ANY_ID, 0},
  82         { 0x8086, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0},
  83         { 0x8086, 0x1013, PCI_ANY_ID, PCI_ANY_ID, 0},
  84         { 0x8086, 0x1014, PCI_ANY_ID, PCI_ANY_ID, 0},
  85         { 0x8086, 0x1015, PCI_ANY_ID, PCI_ANY_ID, 0},
  86         { 0x8086, 0x1016, PCI_ANY_ID, PCI_ANY_ID, 0},
  87         { 0x8086, 0x1017, PCI_ANY_ID, PCI_ANY_ID, 0},
  88         { 0x8086, 0x1018, PCI_ANY_ID, PCI_ANY_ID, 0},
  89         { 0x8086, 0x1019, PCI_ANY_ID, PCI_ANY_ID, 0},
  90         { 0x8086, 0x101A, PCI_ANY_ID, PCI_ANY_ID, 0},
  91         { 0x8086, 0x101D, PCI_ANY_ID, PCI_ANY_ID, 0},
  92         { 0x8086, 0x101E, PCI_ANY_ID, PCI_ANY_ID, 0},
  93         /* required last entry */
  94         { 0, 0, 0, 0, 0}
  95 };
  96
  97 /*********************************************************************
  98  *  Table of branding strings for all supported NICs.
  99  *********************************************************************/
 100
 101 static char *em_strings[] = {
 102         "Intel(R) PRO/1000 Network Connection"
 103 };
 104
 105 /*********************************************************************
 106  *  Function prototypes
 107  *********************************************************************/
 108 static int  em_probe(device_t);
 109 static int  em_attach(device_t);
 110 static int  em_detach(device_t);
 111 static int  em_shutdown(device_t);
 112 static void em_intr(void *);
 113 static void em_start(struct ifnet *);
 114 static int  em_ioctl(struct ifnet *, u_long, caddr_t);
 115 static void em_watchdog(struct ifnet *);
 116 static void em_init(void *);
 117 static void em_stop(void *);
 118 static void em_media_status(struct ifnet *, struct ifmediareq *);
 119 static int  em_media_change(struct ifnet *);
 120 static void em_identify_hardware(struct adapter *);
 121 static int  em_allocate_pci_resources(struct adapter *);
 122 static void em_free_pci_resources(struct adapter *);
 123 static void em_local_timer(void *);
 124 static int  em_hardware_init(struct adapter *);
 125 static void em_setup_interface(device_t, struct adapter *);
 126 static int  em_setup_transmit_structures(struct adapter *);
 127 static void em_initialize_transmit_unit(struct adapter *);
 128 static int  em_setup_receive_structures(struct adapter *);
 129 static void em_initialize_receive_unit(struct adapter *);
 130 static void em_enable_intr(struct adapter *);
 131 static void em_disable_intr(struct adapter *);
 132 static void em_free_transmit_structures(struct adapter *);
 133 static void em_free_receive_structures(struct adapter *);
 134 static void em_update_stats_counters(struct adapter *);
 135 static void em_clean_transmit_interrupts(struct adapter *);
 136 static int  em_allocate_receive_structures(struct adapter *);
 137 static int  em_allocate_transmit_structures(struct adapter *);
 138 static void em_process_receive_interrupts(struct adapter *, int);
 139 static void em_receive_checksum(struct adapter *,
 140                                 struct em_rx_desc *,
 141                                 struct mbuf *);
 142 static void em_transmit_checksum_setup(struct adapter *,
 143                                        struct mbuf *,
 144                                        u_int32_t *,
 145                                        u_int32_t *);
 146 static void em_set_promisc(struct adapter *);
 147 static void em_disable_promisc(struct adapter *);
 148 static void em_set_multi(struct adapter *);
 149 static void em_print_hw_stats(struct adapter *);
 150 static void em_print_link_status(struct adapter *);
 151 static int  em_get_buf(int i, struct adapter *,
 152                        struct mbuf *);
 153 static void em_enable_vlans(struct adapter *);
 154 static int  em_encap(struct adapter *, struct mbuf *);
 155 static void em_smartspeed(struct adapter *);
 156 static int  em_82547_fifo_workaround(struct adapter *, int);
 157 static void em_82547_update_fifo_head(struct adapter *, int);
 158 static int  em_82547_tx_fifo_reset(struct adapter *);
 159 static void em_82547_move_tail(void *arg);
 160 static void em_print_debug_info(struct adapter *);
 161 static int  em_is_valid_ether_addr(u_int8_t *);
 162 static int  em_sysctl_stats(SYSCTL_HANDLER_ARGS);
 163 static int  em_sysctl_debug_info(SYSCTL_HANDLER_ARGS);
 164
 165 /*********************************************************************
 166  *  FreeBSD Device Interface Entry Points
 167  *********************************************************************/
 168
 169 static device_method_t em_methods[] = {
 170         /* Device interface */
 171         DEVMETHOD(device_probe, em_probe),
 172         DEVMETHOD(device_attach, em_attach),
 173         DEVMETHOD(device_detach, em_detach),
 174         DEVMETHOD(device_shutdown, em_shutdown),
 175         {0, 0}
 176 };
 177
 178 static driver_t em_driver = {
 179         "em", em_methods, sizeof(struct adapter ),
 180 };
 181
 182 static devclass_t em_devclass;
 183
 184 DECLARE_DUMMY_MODULE(if_em);
 185 DRIVER_MODULE(if_em, pci, em_driver, em_devclass, 0, 0);
 186
 187 /*********************************************************************
 188  *  Device identification routine
 189  *
 190  *  em_probe determines if the driver should be loaded on
 191  *  adapter based on PCI vendor/device id of the adapter.
 192  *
 193  *  return 0 on success, positive on failure
 194  *********************************************************************/
 195
 196 static int
 197 em_probe(device_t dev)
 198 {
 199         em_vendor_info_t *ent;
 200
 201         u_int16_t       pci_vendor_id = 0;
 202         u_int16_t       pci_device_id = 0;
 203         u_int16_t       pci_subvendor_id = 0;
 204         u_int16_t       pci_subdevice_id = 0;
 205         char            adapter_name[60];
 206
 207         INIT_DEBUGOUT("em_probe: begin");
 208
 209         pci_vendor_id = pci_get_vendor(dev);
 210         if (pci_vendor_id != EM_VENDOR_ID)
 211                 return(ENXIO);
 212
 213         pci_device_id = pci_get_device(dev);
 214         pci_subvendor_id = pci_get_subvendor(dev);
 215         pci_subdevice_id = pci_get_subdevice(dev);
 216
 217         ent = em_vendor_info_array;
 218         while (ent->vendor_id != 0) {
 219                 if ((pci_vendor_id == ent->vendor_id) &&
 220                     (pci_device_id == ent->device_id) &&
 221
 222                     ((pci_subvendor_id == ent->subvendor_id) ||
 223                      (ent->subvendor_id == PCI_ANY_ID)) &&
 224
 225                     ((pci_subdevice_id == ent->subdevice_id) ||
 226                      (ent->subdevice_id == PCI_ANY_ID))) {
 227                         sprintf(adapter_name, "%s, Version - %s",
 228                                 em_strings[ent->index],
 229                                 em_driver_version);
 230                         device_set_desc_copy(dev, adapter_name);
 231                         return(0);
 232                 }
 233                 ent++;
 234         }
 235
 236         return(ENXIO);
 237 }
 238
 239 /*********************************************************************
 240  *  Device initialization routine
 241  *
 242  *  The attach entry point is called when the driver is being loaded.
 243  *  This routine identifies the type of hardware, allocates all resources
 244  *  and initializes the hardware.
 245  *
 246  *  return 0 on success, positive on failure
 247  *********************************************************************/
 248
 249 static int
 250 em_attach(device_t dev)
 251 {
 252         struct adapter * adapter;
 253         int             s;
 254         int             tsize, rsize;
 255         int             error = 0;
 256
 257         INIT_DEBUGOUT("em_attach: begin");
 258         s = splimp();
 259
 260         /* Allocate, clear, and link in our adapter structure */
 261         if (!(adapter = device_get_softc(dev))) {
 262                 printf("em: adapter structure allocation failed\n");
 263                 splx(s);
 264                 return(ENOMEM);
 265         }
 266         bzero(adapter, sizeof(struct adapter ));
 267         adapter->dev = dev;
 268         adapter->osdep.dev = dev;
 269         adapter->unit = device_get_unit(dev);
 270
 271         if (em_adapter_list != NULL)
 272                 em_adapter_list->prev = adapter;
 273         adapter->next = em_adapter_list;
 274         em_adapter_list = adapter;
 275
 276         /* SYSCTL stuff */
 277         sysctl_ctx_init(&adapter->sysctl_ctx);
 278         adapter->sysctl_tree = SYSCTL_ADD_NODE(&adapter->sysctl_ctx,
 279                                                SYSCTL_STATIC_CHILDREN(_hw),
 280                                                OID_AUTO,
 281                                                device_get_nameunit(dev),
 282                                                CTLFLAG_RD,
 283                                                0, "");
 284         if (adapter->sysctl_tree == NULL) {
 285                 error = EIO;
 286                 goto err_sysctl;
 287         }
 288
 289         SYSCTL_ADD_PROC(&adapter->sysctl_ctx,
 290                         SYSCTL_CHILDREN(adapter->sysctl_tree),
 291                         OID_AUTO, "debug_info", CTLTYPE_INT|CTLFLAG_RW,
 292                         (void *)adapter, 0,
 293                         em_sysctl_debug_info, "I", "Debug Information");
 294
 295         SYSCTL_ADD_PROC(&adapter->sysctl_ctx,
 296                         SYSCTL_CHILDREN(adapter->sysctl_tree),
 297                         OID_AUTO, "stats", CTLTYPE_INT|CTLFLAG_RW,
 298                         (void *)adapter, 0,
 299                         em_sysctl_stats, "I", "Statistics");
 300
 301         callout_handle_init(&adapter->timer_handle);
 302         callout_handle_init(&adapter->tx_fifo_timer_handle);
 303
 304         /* Determine hardware revision */
 305         em_identify_hardware(adapter);
 306
 307         /* Parameters (to be read from user) */
 308         adapter->num_tx_desc = EM_MAX_TXD;
 309         adapter->num_rx_desc = EM_MAX_RXD;
 310         adapter->tx_int_delay = EM_TIDV;
 311         adapter->tx_abs_int_delay = EM_TADV;
 312         adapter->rx_int_delay = EM_RDTR;
 313         adapter->rx_abs_int_delay = EM_RADV;
 314         adapter->hw.autoneg = DO_AUTO_NEG;
 315         adapter->hw.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT;
 316         adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
 317         adapter->hw.tbi_compatibility_en = TRUE;
 318         adapter->rx_buffer_len = EM_RXBUFFER_2048;
 319
 320         /*
 321          * These parameters control the automatic generation(Tx) and
 322          * response(Rx) to Ethernet PAUSE frames.
 323          */
 324         adapter->hw.fc_high_water = FC_DEFAULT_HI_THRESH;
 325         adapter->hw.fc_low_water  = FC_DEFAULT_LO_THRESH;
 326         adapter->hw.fc_pause_time = FC_DEFAULT_TX_TIMER;
 327         adapter->hw.fc_send_xon   = TRUE;
 328         adapter->hw.fc = em_fc_full;
 329
 330         adapter->hw.phy_init_script = 1;
 331
 332         /*
 333          * Set the max frame size assuming standard ethernet
 334          * sized frames
 335          */
 336         adapter->hw.max_frame_size =
 337                 ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN;
 338
 339         adapter->hw.min_frame_size =
 340                 MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN;
 341
 342         /*
 343          * This controls when hardware reports transmit completion
 344          * status.
 345          */
 346         adapter->hw.report_tx_early = 1;
 347
 348
 349         if (em_allocate_pci_resources(adapter)) {
 350                 printf("em%d: Allocation of PCI resources failed\n",
 351                        adapter->unit);
 352                 error = ENXIO;
 353                 goto err_pci;
 354         }
 355
 356         em_init_eeprom_params(&adapter->hw);
 357
 358         tsize = EM_ROUNDUP(adapter->num_tx_desc *
 359                            sizeof(struct em_tx_desc), 4096);
 360
 361         /* Allocate Transmit Descriptor ring */
 362         if (!(adapter->tx_desc_base = (struct em_tx_desc *)
 363               contigmalloc(tsize, M_DEVBUF, M_NOWAIT, 0, ~0,
 364                            PAGE_SIZE, 0))) {
 365                 printf("em%d: Unable to allocate TxDescriptor memory\n",
 366                        adapter->unit);
 367                 error = ENOMEM;
 368                 goto err_tx_desc;
 369         }
 370
 371         rsize = EM_ROUNDUP(adapter->num_rx_desc *
 372                            sizeof(struct em_rx_desc), 4096);
 373
 374         /* Allocate Receive Descriptor ring */
 375         if (!(adapter->rx_desc_base = (struct em_rx_desc *)
 376               contigmalloc(rsize, M_DEVBUF, M_NOWAIT, 0, ~0,
 377                            PAGE_SIZE, 0))) {
 378                 printf("em%d: Unable to allocate rx_desc memory\n",
 379                        adapter->unit);
 380                 error = ENOMEM;
 381                 goto err_rx_desc;
 382         }
 383
 384         /* Initialize the hardware */
 385         if (em_hardware_init(adapter)) {
 386                 printf("em%d: Unable to initialize the hardware\n",
 387                        adapter->unit);
 388                 error = EIO;
 389                 goto err_hw_init;
 390         }
 391
 392         /* Copy the permanent MAC address out of the EEPROM */
 393         if (em_read_mac_addr(&adapter->hw) < 0) {
 394                 printf("em%d: EEPROM read error while reading mac address\n",
 395                        adapter->unit);
 396                 error = EIO;
 397                 goto err_mac_addr;
 398         }
 399
 400         if (!em_is_valid_ether_addr(adapter->hw.mac_addr)) {
 401                 printf("em%d: Invalid mac address\n", adapter->unit);
 402                 error = EIO;
 403                 goto err_mac_addr;
 404         }
 405
 406
 407         bcopy(adapter->hw.mac_addr, adapter->interface_data.ac_enaddr,
 408               ETHER_ADDR_LEN);
 409
 410         /* Setup OS specific network interface */
 411         em_setup_interface(dev, adapter);
 412
 413         /* Initialize statistics */
 414         em_clear_hw_cntrs(&adapter->hw);
 415         em_update_stats_counters(adapter);
 416         adapter->hw.get_link_status = 1;
 417         em_check_for_link(&adapter->hw);
 418
 419         /* Print the link status */
 420         if (adapter->link_active == 1) {
 421                 em_get_speed_and_duplex(&adapter->hw, &adapter->link_speed,
 422                                         &adapter->link_duplex);
 423                 printf("em%d:  Speed:%d Mbps  Duplex:%s\n",
 424                        adapter->unit,
 425                        adapter->link_speed,
 426                        adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half");
 427         } else
 428                 printf("em%d:  Speed:N/A  Duplex:N/A\n", adapter->unit);
 429
 430         INIT_DEBUGOUT("em_attach: end");
 431         splx(s);
 432         return(error);
 433
 434
 435 err_mac_addr:
 436 err_hw_init:
 437         contigfree(adapter->rx_desc_base, rsize, M_DEVBUF);
 438 err_rx_desc:
 439         contigfree(adapter->tx_desc_base, tsize, M_DEVBUF);
 440 err_tx_desc:
 441 err_pci:
 442         em_free_pci_resources(adapter);
 443         sysctl_ctx_free(&adapter->sysctl_ctx);
 444 err_sysctl:
 445         splx(s);
 446         return(error);
 447 }
 448
 449 /*********************************************************************
 450  *  Device removal routine
 451  *
 452  *  The detach entry point is called when the driver is being removed.
 453  *  This routine stops the adapter and deallocates all the resources
 454  *  that were allocated for driver operation.
 455  *
 456  *  return 0 on success, positive on failure
 457  *********************************************************************/
 458
 459 static int
 460 em_detach(device_t dev)
 461 {
 462         struct adapter * adapter = device_get_softc(dev);
 463         struct ifnet   *ifp = &adapter->interface_data.ac_if;
 464         int             s;
 465         int             size;
 466
 467         INIT_DEBUGOUT("em_detach: begin");
 468         s = splimp();
 469
 470         em_stop(adapter);
 471         em_phy_hw_reset(&adapter->hw);
 472 #if defined(__DragonFly__) || __FreeBSD_version < 500000
 473         ether_ifdetach(&adapter->interface_data.ac_if, ETHER_BPF_SUPPORTED);
 474 #else
 475         ether_ifdetach(&adapter->interface_data.ac_if);
 476 #endif
 477         em_free_pci_resources(adapter);
 478
 479         size = EM_ROUNDUP(adapter->num_tx_desc *
 480                           sizeof(struct em_tx_desc), 4096);
 481
 482         /* Free Transmit Descriptor ring */
 483         if (adapter->tx_desc_base) {
 484                 contigfree(adapter->tx_desc_base, size, M_DEVBUF);
 485                 adapter->tx_desc_base = NULL;
 486         }
 487
 488         size = EM_ROUNDUP(adapter->num_rx_desc *
 489                           sizeof(struct em_rx_desc), 4096);
 490
 491         /* Free Receive Descriptor ring */
 492         if (adapter->rx_desc_base) {
 493                 contigfree(adapter->rx_desc_base, size, M_DEVBUF);
 494                 adapter->rx_desc_base = NULL;
 495         }
 496
 497         /* Remove from the adapter list */
 498         if (em_adapter_list == adapter)
 499                 em_adapter_list = adapter->next;
 500         if (adapter->next != NULL)
 501                 adapter->next->prev = adapter->prev;
 502         if (adapter->prev != NULL)
 503                 adapter->prev->next = adapter->next;
 504
 505         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 506         ifp->if_timer = 0;
 507
 508         adapter->sysctl_tree = NULL;
 509         sysctl_ctx_free(&adapter->sysctl_ctx);
 510
 511         splx(s);
 512         return(0);
 513 }
 514
 515 /*********************************************************************
 516  *
 517  *  Shutdown entry point
 518  *
 519  **********************************************************************/
 520
 521 static int
 522 em_shutdown(device_t dev)
 523 {
 524         struct adapter *adapter = device_get_softc(dev);
 525         em_stop(adapter);
 526         return(0);
 527 }
 528
 529
 530 /*********************************************************************
 531  *  Transmit entry point
 532  *
 533  *  em_start is called by the stack to initiate a transmit.
 534  *  The driver will remain in this routine as long as there are
 535  *  packets to transmit and transmit resources are available.
 536  *  In case resources are not available stack is notified and
 537  *  the packet is requeued.
 538  **********************************************************************/
 539
 540 static void
 541 em_start(struct ifnet *ifp)
 542 {
 543         int             s;
 544         struct mbuf    *m_head;
 545         struct adapter *adapter = ifp->if_softc;
 546
 547         if (!adapter->link_active)
 548                 return;
 549
 550         s = splimp();
 551         while (ifp->if_snd.ifq_head != NULL) {
 552
 553                 IF_DEQUEUE(&ifp->if_snd, m_head);
 554
 555                 if (m_head == NULL) break;
 556
 557                 if (em_encap(adapter, m_head)) {
 558                         ifp->if_flags |= IFF_OACTIVE;
 559                         IF_PREPEND(&ifp->if_snd, m_head);
 560                         break;
 561                 }
 562
 563                 /* Send a copy of the frame to the BPF listener */
 564 #if defined(__DragonFly__) || __FreeBSD_version < 500000
 565                 if (ifp->if_bpf)
 566                         bpf_mtap(ifp, m_head);
 567 #else
 568                 BPF_MTAP(ifp, m_head);
 569 #endif
 570
 571                 /* Set timeout in case hardware has problems transmitting */
 572                 ifp->if_timer = EM_TX_TIMEOUT;
 573
 574         }
 575         splx(s);
 576         return;
 577 }
 578
 579 /*********************************************************************
 580  *  Ioctl entry point
 581  *
 582  *  em_ioctl is called when the user wants to configure the
 583  *  interface.
 584  *
 585  *  return 0 on success, positive on failure
 586  **********************************************************************/
 587
 588 static int
 589 em_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 590 {
 591         int             s, mask, error = 0;
 592         struct ifreq   *ifr = (struct ifreq *) data;
 593         struct adapter * adapter = ifp->if_softc;
 594
 595         s = splimp();
 596         switch (command) {
 597         case SIOCSIFADDR:
 598         case SIOCGIFADDR:
 599                 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFADDR (Get/Set Interface Addr)");
 600                 ether_ioctl(ifp, command, data);
 601                 break;
 602         case SIOCSIFMTU:
 603                 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)");
 604                 if (ifr->ifr_mtu > MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN) {
 605                         error = EINVAL;
 606                 } else {
 607                         ifp->if_mtu = ifr->ifr_mtu;
 608                         adapter->hw.max_frame_size =
 609                         ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
 610                         em_init(adapter);
 611                 }
 612                 break;
 613         case SIOCSIFFLAGS:
 614                 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)");
 615                 if (ifp->if_flags & IFF_UP) {
 616                         if (!(ifp->if_flags & IFF_RUNNING))
 617                                 em_init(adapter);
 618
 619                         em_disable_promisc(adapter);
 620                         em_set_promisc(adapter);
 621                 } else {
 622                         if (ifp->if_flags & IFF_RUNNING) {
 623                                 em_stop(adapter);
 624                         }
 625                 }
 626                 break;
 627         case SIOCADDMULTI:
 628         case SIOCDELMULTI:
 629                 IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI");
 630                 if (ifp->if_flags & IFF_RUNNING) {
 631                         em_disable_intr(adapter);
 632                         em_set_multi(adapter);
 633                         if (adapter->hw.mac_type == em_82542_rev2_0) {
 634                                 em_initialize_receive_unit(adapter);
 635                         }
 636 #ifdef DEVICE_POLLING
 637                         if (!(ifp->if_ipending & IFF_POLLING))
 638 #endif
 639                                 em_enable_intr(adapter);
 640                 }
 641                 break;
 642         case SIOCSIFMEDIA:
 643         case SIOCGIFMEDIA:
 644                 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)");
 645                 error = ifmedia_ioctl(ifp, ifr, &adapter->media, command);
 646                 break;
 647         case SIOCSIFCAP:
 648                 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)");
 649                 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
 650                 if (mask & IFCAP_HWCSUM) {
 651                         if (IFCAP_HWCSUM & ifp->if_capenable)
 652                                 ifp->if_capenable &= ~IFCAP_HWCSUM;
 653                         else
 654                                 ifp->if_capenable |= IFCAP_HWCSUM;
 655                         if (ifp->if_flags & IFF_RUNNING)
 656                                 em_init(adapter);
 657                 }
 658                 break;
 659         default:
 660                 IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%d)\n", (int)command);
 661                 error = EINVAL;
 662         }
 663
 664         splx(s);
 665         return(error);
 666 }
 667
 668 /*********************************************************************
 669  *  Watchdog entry point
 670  *
 671  *  This routine is called whenever hardware quits transmitting.
 672  *
 673  **********************************************************************/
 674
 675 static void
 676 em_watchdog(struct ifnet *ifp)
 677 {
 678         struct adapter * adapter;
 679         adapter = ifp->if_softc;
 680
 681         /* If we are in this routine because of pause frames, then
 682          * don't reset the hardware.
 683          */
 684         if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF) {
 685                 ifp->if_timer = EM_TX_TIMEOUT;
 686                 return;
 687         }
 688
 689         printf("em%d: watchdog timeout -- resetting\n", adapter->unit);
 690
 691         ifp->if_flags &= ~IFF_RUNNING;
 692
 693         em_stop(adapter);
 694         em_init(adapter);
 695
 696         ifp->if_oerrors++;
 697         return;
 698 }
 699
 700 /*********************************************************************
 701  *  Init entry point
 702  *
 703  *  This routine is used in two ways. It is used by the stack as
 704  *  init entry point in network interface structure. It is also used
 705  *  by the driver as a hw/sw initialization routine to get to a
 706  *  consistent state.
 707  *
 708  *  return 0 on success, positive on failure
 709  **********************************************************************/
 710
 711 static void
 712 em_init(void *arg)
 713 {
 714         int             s;
 715         struct ifnet   *ifp;
 716         struct adapter * adapter = arg;
 717
 718         INIT_DEBUGOUT("em_init: begin");
 719
 720         s = splimp();
 721
 722         em_stop(adapter);
 723
 724         /* Initialize the hardware */
 725         if (em_hardware_init(adapter)) {
 726                 printf("em%d: Unable to initialize the hardware\n",
 727                        adapter->unit);
 728                 splx(s);
 729                 return;
 730         }
 731
 732         em_enable_vlans(adapter);
 733
 734         /* Prepare transmit descriptors and buffers */
 735         if (em_setup_transmit_structures(adapter)) {
 736                 printf("em%d: Could not setup transmit structures\n",
 737                        adapter->unit);
 738                 em_stop(adapter);
 739                 splx(s);
 740                 return;
 741         }
 742         em_initialize_transmit_unit(adapter);
 743
 744         /* Setup Multicast table */
 745         em_set_multi(adapter);
 746
 747         /* Prepare receive descriptors and buffers */
 748         if (em_setup_receive_structures(adapter)) {
 749                 printf("em%d: Could not setup receive structures\n",
 750                        adapter->unit);
 751                 em_stop(adapter);
 752                 splx(s);
 753                 return;
 754         }
 755         em_initialize_receive_unit(adapter);
 756
 757         ifp = &adapter->interface_data.ac_if;
 758         ifp->if_flags |= IFF_RUNNING;
 759         ifp->if_flags &= ~IFF_OACTIVE;
 760
 761         if (adapter->hw.mac_type >= em_82543) {
 762                 if (ifp->if_capenable & IFCAP_TXCSUM)
 763                         ifp->if_hwassist = EM_CHECKSUM_FEATURES;
 764                 else
 765                         ifp->if_hwassist = 0;
 766         }
 767
 768         adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz);
 769         em_clear_hw_cntrs(&adapter->hw);
 770 #ifdef DEVICE_POLLING
 771         /*
 772          * Only enable interrupts if we are not polling, make sure
 773          * they are off otherwise.
 774          */
 775         if (ifp->if_ipending & IFF_POLLING)
 776                 em_disable_intr(adapter);
 777         else
 778 #endif /* DEVICE_POLLING */
 779                 em_enable_intr(adapter);
 780
 781         splx(s);
 782         return;
 783 }
 784
 785
 786 #ifdef DEVICE_POLLING
 787 static poll_handler_t em_poll;
 788
 789 static void
 790 em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
 791 {
 792         struct adapter *adapter = ifp->if_softc;
 793         u_int32_t reg_icr;
 794
 795         if (cmd == POLL_DEREGISTER) {       /* final call, enable interrupts */
 796                 em_enable_intr(adapter);
 797                 return;
 798         }
 799         if (cmd == POLL_AND_CHECK_STATUS) {
 800                 reg_icr = E1000_READ_REG(&adapter->hw, ICR);
 801                 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
 802                         untimeout(em_local_timer, adapter, adapter->timer_handle);
 803                         adapter->hw.get_link_status = 1;
 804                         em_check_for_link(&adapter->hw);
 805                         em_print_link_status(adapter);
 806                         adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz);
 807                 }
 808         }
 809         if (ifp->if_flags & IFF_RUNNING) {
 810                 em_process_receive_interrupts(adapter, count);
 811                 em_clean_transmit_interrupts(adapter);
 812         }
 813
 814         if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL)
 815                 em_start(ifp);
 816 }
 817 #endif /* DEVICE_POLLING */
 818
 819 /*********************************************************************
 820  *
 821  *  Interrupt Service routine
 822  *
 823  **********************************************************************/
 824 static void
 825 em_intr(void *arg)
 826 {
 827         u_int32_t       loop_cnt = EM_MAX_INTR;
 828         u_int32_t       reg_icr;
 829         struct ifnet    *ifp;
 830         struct adapter  *adapter = arg;
 831
 832         ifp = &adapter->interface_data.ac_if;
 833
 834 #ifdef DEVICE_POLLING
 835         if (ifp->if_ipending & IFF_POLLING)
 836                 return;
 837
 838         if (ether_poll_register(em_poll, ifp)) {
 839                 em_disable_intr(adapter);
 840                 em_poll(ifp, 0, 1);
 841                 return;
 842         }
 843 #endif /* DEVICE_POLLING */
 844
 845         reg_icr = E1000_READ_REG(&adapter->hw, ICR);
 846         if (!reg_icr) {
 847                 return;
 848         }
 849
 850         /* Link status change */
 851         if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
 852                 untimeout(em_local_timer, adapter,
 853                           adapter->timer_handle);
 854                 adapter->hw.get_link_status = 1;
 855                 em_check_for_link(&adapter->hw);
 856                 em_print_link_status(adapter);
 857                 adapter->timer_handle =
 858                 timeout(em_local_timer, adapter, 2*hz);
 859         }
 860
 861         while (loop_cnt > 0) {
 862                 if (ifp->if_flags & IFF_RUNNING) {
 863                         em_process_receive_interrupts(adapter, -1);
 864                         em_clean_transmit_interrupts(adapter);
 865                 }
 866                 loop_cnt--;
 867         }
 868
 869         if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL)
 870                 em_start(ifp);
 871
 872         return;
 873 }
 874
 875
 876
 877 /*********************************************************************
 878  *
 879  *  Media Ioctl callback
 880  *
 881  *  This routine is called whenever the user queries the status of
 882  *  the interface using ifconfig.
 883  *
 884  **********************************************************************/
 885 static void
 886 em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
 887 {
 888         struct adapter * adapter = ifp->if_softc;
 889
 890         INIT_DEBUGOUT("em_media_status: begin");
 891
 892         em_check_for_link(&adapter->hw);
 893         if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
 894                 if (adapter->link_active == 0) {
 895                         em_get_speed_and_duplex(&adapter->hw,
 896                                                 &adapter->link_speed,
 897                                                 &adapter->link_duplex);
 898                         adapter->link_active = 1;
 899                 }
 900         } else {
 901                 if (adapter->link_active == 1) {
 902                         adapter->link_speed = 0;
 903                         adapter->link_duplex = 0;
 904                         adapter->link_active = 0;
 905                 }
 906         }
 907
 908         ifmr->ifm_status = IFM_AVALID;
 909         ifmr->ifm_active = IFM_ETHER;
 910
 911         if (!adapter->link_active)
 912                 return;
 913
 914         ifmr->ifm_status |= IFM_ACTIVE;
 915
 916         if (adapter->hw.media_type == em_media_type_fiber) {
 917                 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX;
 918         } else {
 919                 switch (adapter->link_speed) {
 920                 case 10:
 921                         ifmr->ifm_active |= IFM_10_T;
 922                         break;
 923                 case 100:
 924                         ifmr->ifm_active |= IFM_100_TX;
 925                         break;
 926                 case 1000:
 927 #if defined(__DragonFly__) || __FreeBSD_version < 500000
 928                         ifmr->ifm_active |= IFM_1000_TX;
 929 #else
 930                         ifmr->ifm_active |= IFM_1000_T;
 931 #endif
 932                         break;
 933                 }
 934                 if (adapter->link_duplex == FULL_DUPLEX)
 935                         ifmr->ifm_active |= IFM_FDX;
 936                 else
 937                         ifmr->ifm_active |= IFM_HDX;
 938         }
 939         return;
 940 }
 941
 942 /*********************************************************************
 943  *
 944  *  Media Ioctl callback
 945  *
 946  *  This routine is called when the user changes speed/duplex using
 947  *  media/mediopt option with ifconfig.
 948  *
 949  **********************************************************************/
 950 static int
 951 em_media_change(struct ifnet *ifp)
 952 {
 953         struct adapter * adapter = ifp->if_softc;
 954         struct ifmedia  *ifm = &adapter->media;
 955
 956         INIT_DEBUGOUT("em_media_change: begin");
 957
 958         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
 959                 return(EINVAL);
 960
 961         switch (IFM_SUBTYPE(ifm->ifm_media)) {
 962         case IFM_AUTO:
 963                 adapter->hw.autoneg = DO_AUTO_NEG;
 964                 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
 965                 break;
 966         case IFM_1000_SX:
 967 #if defined(__DragonFly__) || __FreeBSD_version < 500000
 968         case IFM_1000_TX:
 969 #else
 970         case IFM_1000_T:
 971 #endif
 972                 adapter->hw.autoneg = DO_AUTO_NEG;
 973                 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
 974                 break;
 975         case IFM_100_TX:
 976                 adapter->hw.autoneg = FALSE;
 977                 adapter->hw.autoneg_advertised = 0;
 978                 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
 979                         adapter->hw.forced_speed_duplex = em_100_full;
 980                 else
 981                         adapter->hw.forced_speed_duplex = em_100_half;
 982                 break;
 983         case IFM_10_T:
 984                 adapter->hw.autoneg = FALSE;
 985                 adapter->hw.autoneg_advertised = 0;
 986                 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX)
 987                         adapter->hw.forced_speed_duplex = em_10_full;
 988                 else
 989                         adapter->hw.forced_speed_duplex = em_10_half;
 990                 break;
 991         default:
 992                 printf("em%d: Unsupported media type\n", adapter->unit);
 993         }
 994
 995         em_init(adapter);
 996
 997         return(0);
 998 }
 999
1000 #define EM_FIFO_HDR              0x10
1001 #define EM_82547_PKT_THRESH      0x3e0
1002 #define EM_82547_TX_FIFO_SIZE    0x2800
1003 #define EM_82547_TX_FIFO_BEGIN   0xf00
1004 /*********************************************************************
1005  *
1006  *  This routine maps the mbufs to tx descriptors.
1007  *
1008  *  return 0 on success, positive on failure
1009  **********************************************************************/
1010
1011 static int
1012 em_encap(struct adapter *adapter, struct mbuf *m_head)
1013 {
1014         vm_offset_t     virtual_addr;
1015         u_int32_t       txd_upper;
1016         u_int32_t       txd_lower;
1017         int             txd_used, i, txd_saved;
1018         struct mbuf     *mp;
1019
1020 #if defined(__DragonFly__) || __FreeBSD_version < 500000
1021         struct ifvlan *ifv = NULL;
1022 #else
1023         struct m_tag    *mtag;
1024 #endif
1025         struct em_buffer   *tx_buffer = NULL;
1026         struct em_tx_desc *current_tx_desc = NULL;
1027         struct ifnet   *ifp = &adapter->interface_data.ac_if;
1028
1029         /*
1030          * Force a cleanup if number of TX descriptors
1031          * available hits the threshold
1032          */
1033         if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD)
1034                 em_clean_transmit_interrupts(adapter);
1035
1036         if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) {
1037                 adapter->no_tx_desc_avail1++;
1038                 return (ENOBUFS);
1039         }
1040
1041         if (ifp->if_hwassist > 0) {
1042                 em_transmit_checksum_setup(adapter,  m_head,
1043                                            &txd_upper, &txd_lower);
1044         }
1045         else
1046                 txd_upper = txd_lower = 0;
1047
1048
1049         /* Find out if we are in vlan mode */
1050 #if defined(__DragonFly__) || __FreeBSD_version < 500000
1051         if ((m_head->m_flags & (M_PROTO1|M_PKTHDR)) == (M_PROTO1|M_PKTHDR) &&
1052             m_head->m_pkthdr.rcvif != NULL &&
1053             m_head->m_pkthdr.rcvif->if_type == IFT_L2VLAN)
1054                 ifv = m_head->m_pkthdr.rcvif->if_softc;
1055 #else
1056         mtag = VLAN_OUTPUT_TAG(ifp, m_head);
1057 #endif
1058
1059         i = adapter->next_avail_tx_desc;
1060         txd_saved = i;
1061         txd_used = 0;
1062         for (mp = m_head; mp != NULL; mp = mp->m_next) {
1063                 if (mp->m_len == 0)
1064                         continue;
1065
1066                 if (txd_used == adapter->num_tx_desc_avail) {
1067                         adapter->next_avail_tx_desc = txd_saved;
1068                         adapter->no_tx_desc_avail2++;
1069                         return (ENOBUFS);
1070                 }
1071
1072                 tx_buffer = &adapter->tx_buffer_area[i];
1073                 current_tx_desc = &adapter->tx_desc_base[i];
1074                 virtual_addr = mtod(mp, vm_offset_t);
1075                 current_tx_desc->buffer_addr = vtophys(virtual_addr);
1076
1077                 current_tx_desc->lower.data = (adapter->txd_cmd | txd_lower | mp->m_len);
1078                 current_tx_desc->upper.data = (txd_upper);
1079
1080                 if (++i == adapter->num_tx_desc)
1081                         i = 0;
1082
1083                 tx_buffer->m_head = NULL;
1084
1085                 txd_used++;
1086         }
1087
1088         adapter->num_tx_desc_avail -= txd_used;
1089         adapter->next_avail_tx_desc = i;
1090
1091 #if defined(__DragonFly__) || __FreeBSD_version < 500000
1092         if (ifv != NULL) {
1093                 /* Set the vlan id */
1094                 current_tx_desc->upper.fields.special = ifv->ifv_tag;
1095 #else
1096         if (mtag != NULL) {
1097                 /* Set the vlan id */
1098                 current_tx_desc->upper.fields.special = VLAN_TAG_VALUE(mtag);
1099 #endif
1100                 /* Tell hardware to add tag */
1101                 current_tx_desc->lower.data |= E1000_TXD_CMD_VLE;
1102         }
1103
1104         tx_buffer->m_head = m_head;
1105
1106         /*
1107          * Last Descriptor of Packet needs End Of Packet (EOP)
1108          */
1109         current_tx_desc->lower.data |= (E1000_TXD_CMD_EOP);
1110
1111         /*
1112          * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000
1113          * that this frame is available to transmit.
1114          */
1115         if (adapter->hw.mac_type == em_82547 &&
1116             adapter->link_duplex == HALF_DUPLEX) {
1117                 em_82547_move_tail(adapter);
1118         }
1119         else {
1120                 E1000_WRITE_REG(&adapter->hw, TDT, i);
1121                 if (adapter->hw.mac_type == em_82547) {
1122                         em_82547_update_fifo_head(adapter, m_head->m_pkthdr.len);
1123                 }
1124         }
1125
1126         return (0);
1127 }
1128
1129
1130 /*********************************************************************
1131  *
1132  * 82547 workaround to avoid controller hang in half-duplex environment.
1133  * The workaround is to avoid queuing a large packet that would span
1134  * the internal Tx FIFO ring boundary. We need to reset the FIFO pointers
1135  * in this case. We do that only when FIFO is queiced.
1136  *
1137  **********************************************************************/
1138 static void
1139 em_82547_move_tail(void *arg)
1140 {
1141         int s;
1142         struct adapter *adapter = arg;
1143         uint16_t hw_tdt;
1144         uint16_t sw_tdt;
1145         struct em_tx_desc *tx_desc;
1146         uint16_t length = 0;
1147         boolean_t eop = 0;
1148
1149         s = splimp();
1150         hw_tdt = E1000_READ_REG(&adapter->hw, TDT);
1151         sw_tdt = adapter->next_avail_tx_desc;
1152
1153         while (hw_tdt != sw_tdt) {
1154                 tx_desc = &adapter->tx_desc_base[hw_tdt];
1155                 length += tx_desc->lower.flags.length;
1156                 eop = tx_desc->lower.data & E1000_TXD_CMD_EOP;
1157                 if(++hw_tdt == adapter->num_tx_desc)
1158                         hw_tdt = 0;
1159
1160                 if(eop) {
1161                         if (em_82547_fifo_workaround(adapter, length)) {
1162                                 adapter->tx_fifo_wrk++;
1163                                 adapter->tx_fifo_timer_handle =
1164                                         timeout(em_82547_move_tail,
1165                                                 adapter, 1);
1166                                 splx(s);
1167                                 return;
1168                         }
1169                         else {
1170                                 E1000_WRITE_REG(&adapter->hw, TDT, hw_tdt);
1171                                 em_82547_update_fifo_head(adapter, length);
1172                                 length = 0;
1173                         }
1174                 }
1175         }
1176         splx(s);
1177         return;
1178 }
1179
1180 static int
1181 em_82547_fifo_workaround(struct adapter *adapter, int len)
1182 {
1183         int fifo_space, fifo_pkt_len;
1184
1185         fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR);
1186
1187         if (adapter->link_duplex == HALF_DUPLEX) {
1188                 fifo_space = EM_82547_TX_FIFO_SIZE - adapter->tx_fifo_head;
1189
1190                 if (fifo_pkt_len >= (EM_82547_PKT_THRESH + fifo_space)) {
1191                         if (em_82547_tx_fifo_reset(adapter)) {
1192                                 return(0);
1193                         }
1194                         else {
1195                                 return(1);
1196                         }
1197                 }
1198         }
1199
1200         return(0);
1201 }
1202
1203 static void
1204 em_82547_update_fifo_head(struct adapter *adapter, int len)
1205 {
1206         int fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR);
1207
1208         /* tx_fifo_head is always 16 byte aligned */
1209         adapter->tx_fifo_head += fifo_pkt_len;
1210         if (adapter->tx_fifo_head >= EM_82547_TX_FIFO_SIZE) {
1211                 adapter->tx_fifo_head -= EM_82547_TX_FIFO_SIZE;
1212         }
1213
1214         return;
1215 }
1216
1217
1218 static int
1219 em_82547_tx_fifo_reset(struct adapter *adapter)
1220 {
1221         uint32_t tctl;
1222
1223         if ( (E1000_READ_REG(&adapter->hw, TDT) ==
1224               E1000_READ_REG(&adapter->hw, TDH)) &&
1225              (E1000_READ_REG(&adapter->hw, TDFT) ==
1226               E1000_READ_REG(&adapter->hw, TDFH)) &&
1227              (E1000_READ_REG(&adapter->hw, TDFTS) ==
1228               E1000_READ_REG(&adapter->hw, TDFHS)) &&
1229              (E1000_READ_REG(&adapter->hw, TDFPC) == 0)) {
1230
1231                 /* Disable TX unit */
1232                 tctl = E1000_READ_REG(&adapter->hw, TCTL);
1233                 E1000_WRITE_REG(&adapter->hw, TCTL, tctl & ~E1000_TCTL_EN);
1234
1235                 /* Reset FIFO pointers */
1236                 E1000_WRITE_REG(&adapter->hw, TDFT, EM_82547_TX_FIFO_BEGIN);
1237                 E1000_WRITE_REG(&adapter->hw, TDFH, EM_82547_TX_FIFO_BEGIN);
1238                 E1000_WRITE_REG(&adapter->hw, TDFTS, EM_82547_TX_FIFO_BEGIN);
1239                 E1000_WRITE_REG(&adapter->hw, TDFHS, EM_82547_TX_FIFO_BEGIN);
1240
1241                 /* Re-enable TX unit */
1242                 E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
1243                 E1000_WRITE_FLUSH(&adapter->hw);
1244
1245                 adapter->tx_fifo_head = 0;
1246                 adapter->tx_fifo_reset++;
1247
1248                 return(TRUE);
1249         }
1250         else {
1251                 return(FALSE);
1252         }
1253 }
1254
1255 static void
1256 em_set_promisc(struct adapter * adapter)
1257 {
1258
1259         u_int32_t       reg_rctl;
1260         struct ifnet   *ifp = &adapter->interface_data.ac_if;
1261
1262         reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1263
1264         if (ifp->if_flags & IFF_PROMISC) {
1265                 reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
1266                 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1267         } else if (ifp->if_flags & IFF_ALLMULTI) {
1268                 reg_rctl |= E1000_RCTL_MPE;
1269                 reg_rctl &= ~E1000_RCTL_UPE;
1270                 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1271         }
1272
1273         return;
1274 }
1275
1276 static void
1277 em_disable_promisc(struct adapter * adapter)
1278 {
1279         u_int32_t       reg_rctl;
1280
1281         reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1282
1283         reg_rctl &=  (~E1000_RCTL_UPE);
1284         reg_rctl &=  (~E1000_RCTL_MPE);
1285         E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1286
1287         return;
1288 }
1289
1290
1291 /*********************************************************************
1292  *  Multicast Update
1293  *
1294  *  This routine is called whenever multicast address list is updated.
1295  *
1296  **********************************************************************/
1297
1298 static void
1299 em_set_multi(struct adapter * adapter)
1300 {
1301         u_int32_t reg_rctl = 0;
1302         u_int8_t  mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS];
1303         struct ifmultiaddr  *ifma;
1304         int mcnt = 0;
1305         struct ifnet   *ifp = &adapter->interface_data.ac_if;
1306
1307         IOCTL_DEBUGOUT("em_set_multi: begin");
1308
1309         if (adapter->hw.mac_type == em_82542_rev2_0) {
1310                 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1311                 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
1312                         em_pci_clear_mwi(&adapter->hw);
1313                 }
1314                 reg_rctl |= E1000_RCTL_RST;
1315                 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1316                 msec_delay(5);
1317         }
1318
1319 #if defined(__DragonFly__) || __FreeBSD_version < 500000
1320         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1321 #else
1322         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1323 #endif
1324                 if (ifma->ifma_addr->sa_family != AF_LINK)
1325                         continue;
1326
1327                 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) break;
1328
1329                 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
1330                       &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS);
1331                 mcnt++;
1332         }
1333
1334         if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) {
1335                 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1336                 reg_rctl |= E1000_RCTL_MPE;
1337                 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1338         } else
1339                 em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0);
1340
1341         if (adapter->hw.mac_type == em_82542_rev2_0) {
1342                 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL);
1343                 reg_rctl &= ~E1000_RCTL_RST;
1344                 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1345                 msec_delay(5);
1346                 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) {
1347                         em_pci_set_mwi(&adapter->hw);
1348                 }
1349         }
1350
1351         return;
1352 }
1353
1354
1355 /*********************************************************************
1356  *  Timer routine
1357  *
1358  *  This routine checks for link status and updates statistics.
1359  *
1360  **********************************************************************/
1361
1362 static void
1363 em_local_timer(void *arg)
1364 {
1365         int s;
1366         struct ifnet   *ifp;
1367         struct adapter * adapter = arg;
1368         ifp = &adapter->interface_data.ac_if;
1369
1370         s = splimp();
1371
1372         em_check_for_link(&adapter->hw);
1373         em_print_link_status(adapter);
1374         em_update_stats_counters(adapter);
1375         if (em_display_debug_stats && ifp->if_flags & IFF_RUNNING) {
1376                 em_print_hw_stats(adapter);
1377         }
1378         em_smartspeed(adapter);
1379
1380         adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz);
1381
1382         splx(s);
1383         return;
1384 }
1385
1386 static void
1387 em_print_link_status(struct adapter * adapter)
1388 {
1389         if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
1390                 if (adapter->link_active == 0) {
1391                         em_get_speed_and_duplex(&adapter->hw,
1392                                                 &adapter->link_speed,
1393                                                 &adapter->link_duplex);
1394                         printf("em%d: Link is up %d Mbps %s\n",
1395                                adapter->unit,
1396                                adapter->link_speed,
1397                                ((adapter->link_duplex == FULL_DUPLEX) ?
1398                                 "Full Duplex" : "Half Duplex"));
1399                         adapter->link_active = 1;
1400                         adapter->smartspeed = 0;
1401                 }
1402         } else {
1403                 if (adapter->link_active == 1) {
1404                         adapter->link_speed = 0;
1405                         adapter->link_duplex = 0;
1406                         printf("em%d: Link is Down\n", adapter->unit);
1407                         adapter->link_active = 0;
1408                 }
1409         }
1410
1411         return;
1412 }
1413
1414 /*********************************************************************
1415  *
1416  *  This routine disables all traffic on the adapter by issuing a
1417  *  global reset on the MAC and deallocates TX/RX buffers.
1418  *
1419  **********************************************************************/
1420
1421 static void
1422 em_stop(void *arg)
1423 {
1424         struct ifnet   *ifp;
1425         struct adapter * adapter = arg;
1426         ifp = &adapter->interface_data.ac_if;
1427
1428         INIT_DEBUGOUT("em_stop: begin\n");
1429         em_disable_intr(adapter);
1430         em_reset_hw(&adapter->hw);
1431         untimeout(em_local_timer, adapter, adapter->timer_handle);
1432         untimeout(em_82547_move_tail, adapter,
1433                   adapter->tx_fifo_timer_handle);
1434         em_free_transmit_structures(adapter);
1435         em_free_receive_structures(adapter);
1436
1437
1438         /* Tell the stack that the interface is no longer active */
1439         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1440
1441         return;
1442 }
1443
1444
1445 /*********************************************************************
1446  *
1447  *  Determine hardware revision.
1448  *
1449  **********************************************************************/
1450 static void
1451 em_identify_hardware(struct adapter * adapter)
1452 {
1453         device_t dev = adapter->dev;
1454
1455         /* Make sure our PCI config space has the necessary stuff set */
1456         adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2);
1457         if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) &&
1458               (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) {
1459                 printf("em%d: Memory Access and/or Bus Master bits were not set!\n",
1460                        adapter->unit);
1461                 adapter->hw.pci_cmd_word |=
1462                 (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN);
1463                 pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2);
1464         }
1465
1466         /* Save off the information about this board */
1467         adapter->hw.vendor_id = pci_get_vendor(dev);
1468         adapter->hw.device_id = pci_get_device(dev);
1469         adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1);
1470         adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2);
1471         adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2);
1472
1473         /* Identify the MAC */
1474         if (em_set_mac_type(&adapter->hw))
1475                 printf("em%d: Unknown MAC Type\n", adapter->unit);
1476
1477         return;
1478 }
1479
1480 static int
1481 em_allocate_pci_resources(struct adapter * adapter)
1482 {
1483         int             i, val, rid;
1484         device_t        dev = adapter->dev;
1485
1486         rid = EM_MMBA;
1487         adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY,
1488                                                  &rid, 0, ~0, 1,
1489                                                  RF_ACTIVE);
1490         if (!(adapter->res_memory)) {
1491                 printf("em%d: Unable to allocate bus resource: memory\n",
1492                        adapter->unit);
1493                 return(ENXIO);
1494         }
1495         adapter->osdep.mem_bus_space_tag =
1496         rman_get_bustag(adapter->res_memory);
1497         adapter->osdep.mem_bus_space_handle =
1498         rman_get_bushandle(adapter->res_memory);
1499         adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle;
1500
1501
1502         if (adapter->hw.mac_type > em_82543) {
1503                 /* Figure our where our IO BAR is ? */
1504                 rid = EM_MMBA;
1505                 for (i = 0; i < 5; i++) {
1506                         val = pci_read_config(dev, rid, 4);
1507                         if (val & 0x00000001) {
1508                                 adapter->io_rid = rid;
1509                                 break;
1510                         }
1511                         rid += 4;
1512                 }
1513
1514                 adapter->res_ioport = bus_alloc_resource(dev, SYS_RES_IOPORT,
1515                                                          &adapter->io_rid, 0, ~0, 1,
1516                                                          RF_ACTIVE);
1517                 if (!(adapter->res_ioport)) {
1518                         printf("em%d: Unable to allocate bus resource: ioport\n",
1519                                adapter->unit);
1520                         return(ENXIO);
1521                 }
1522
1523                 adapter->hw.io_base =
1524                 rman_get_start(adapter->res_ioport);
1525         }
1526
1527         rid = 0x0;
1528         adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ,
1529                                                     &rid, 0, ~0, 1,
1530                                                     RF_SHAREABLE | RF_ACTIVE);
1531         if (!(adapter->res_interrupt)) {
1532                 printf("em%d: Unable to allocate bus resource: interrupt\n",
1533                        adapter->unit);
1534                 return(ENXIO);
1535         }
1536         if (bus_setup_intr(dev, adapter->res_interrupt, INTR_TYPE_NET,
1537                            (void (*)(void *)) em_intr, adapter,
1538                            &adapter->int_handler_tag)) {
1539                 printf("em%d: Error registering interrupt handler!\n",
1540                        adapter->unit);
1541                 return(ENXIO);
1542         }
1543
1544         adapter->hw.back = &adapter->osdep;
1545
1546         return(0);
1547 }
1548
1549 static void
1550 em_free_pci_resources(struct adapter * adapter)
1551 {
1552         device_t dev = adapter->dev;
1553
1554         if (adapter->res_interrupt != NULL) {
1555                 bus_teardown_intr(dev, adapter->res_interrupt,
1556                                   adapter->int_handler_tag);
1557                 bus_release_resource(dev, SYS_RES_IRQ, 0,
1558                                      adapter->res_interrupt);
1559         }
1560         if (adapter->res_memory != NULL) {
1561                 bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA,
1562                                      adapter->res_memory);
1563         }
1564
1565         if (adapter->res_ioport != NULL) {
1566                 bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid,
1567                                      adapter->res_ioport);
1568         }
1569         return;
1570 }
1571
1572 /*********************************************************************
1573  *
1574  *  Initialize the hardware to a configuration as specified by the
1575  *  adapter structure. The controller is reset, the EEPROM is
1576  *  verified, the MAC address is set, then the shared initialization
1577  *  routines are called.
1578  *
1579  **********************************************************************/
1580 static int
1581 em_hardware_init(struct adapter * adapter)
1582 {
1583         /* Issue a global reset */
1584         em_reset_hw(&adapter->hw);
1585
1586         /* When hardware is reset, fifo_head is also reset */
1587         adapter->tx_fifo_head = 0;
1588
1589         /* Make sure we have a good EEPROM before we read from it */
1590         if (em_validate_eeprom_checksum(&adapter->hw) < 0) {
1591                 printf("em%d: The EEPROM Checksum Is Not Valid\n",
1592                        adapter->unit);
1593                 return(EIO);
1594         }
1595
1596         if (em_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) {
1597                 printf("em%d: EEPROM read error while reading part number\n",
1598                        adapter->unit);
1599                 return(EIO);
1600         }
1601
1602         if (em_init_hw(&adapter->hw) < 0) {
1603                 printf("em%d: Hardware Initialization Failed",
1604                        adapter->unit);
1605                 return(EIO);
1606         }
1607
1608         em_check_for_link(&adapter->hw);
1609         if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU)
1610                 adapter->link_active = 1;
1611         else
1612                 adapter->link_active = 0;
1613
1614         if (adapter->link_active) {
1615                 em_get_speed_and_duplex(&adapter->hw,
1616                                         &adapter->link_speed,
1617                                         &adapter->link_duplex);
1618         } else {
1619                 adapter->link_speed = 0;
1620                 adapter->link_duplex = 0;
1621         }
1622
1623         return(0);
1624 }
1625
1626 /*********************************************************************
1627  *
1628  *  Setup networking device structure and register an interface.
1629  *
1630  **********************************************************************/
1631 static void
1632 em_setup_interface(device_t dev, struct adapter * adapter)
1633 {
1634         struct ifnet   *ifp;
1635         INIT_DEBUGOUT("em_setup_interface: begin");
1636
1637         ifp = &adapter->interface_data.ac_if;
1638         if_initname(ifp, "em", adapter->unit);
1639         ifp->if_mtu = ETHERMTU;
1640         ifp->if_output = ether_output;
1641         ifp->if_baudrate = 1000000000;
1642         ifp->if_init =  em_init;
1643         ifp->if_softc = adapter;
1644         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1645         ifp->if_ioctl = em_ioctl;
1646         ifp->if_start = em_start;
1647         ifp->if_watchdog = em_watchdog;
1648         ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1;
1649
1650 #if defined(__DragonFly__) || __FreeBSD_version < 500000
1651         ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
1652 #else
1653         ether_ifattach(ifp, adapter->interface_data.ac_enaddr);
1654 #endif
1655
1656         if (adapter->hw.mac_type >= em_82543) {
1657                 ifp->if_capabilities = IFCAP_HWCSUM;
1658                 ifp->if_capenable = ifp->if_capabilities;
1659         }
1660
1661         /*
1662          * Tell the upper layer(s) we support long frames.
1663          */
1664         ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
1665 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
1666         ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
1667 #endif
1668
1669
1670         /*
1671          * Specify the media types supported by this adapter and register
1672          * callbacks to update media and link information
1673          */
1674         ifmedia_init(&adapter->media, IFM_IMASK, em_media_change,
1675                      em_media_status);
1676         if (adapter->hw.media_type == em_media_type_fiber) {
1677                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX,
1678                             0, NULL);
1679                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX,
1680                             0, NULL);
1681         } else {
1682                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL);
1683                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX,
1684                             0, NULL);
1685                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX,
1686                             0, NULL);
1687                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX,
1688                             0, NULL);
1689 #if defined(__DragonFly__) || __FreeBSD_version < 500000
1690                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX,
1691                             0, NULL);
1692                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL);
1693 #else
1694                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX,
1695                             0, NULL);
1696                 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL);
1697 #endif
1698         }
1699         ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL);
1700         ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO);
1701
1702         return;
1703 }
1704
1705
1706 /*********************************************************************
1707  *
1708  *  Workaround for SmartSpeed on 82541 and 82547 controllers
1709  *
1710  **********************************************************************/
1711 static void
1712 em_smartspeed(struct adapter *adapter)
1713 {
1714         uint16_t phy_tmp;
1715
1716         if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) ||
1717            !adapter->hw.autoneg || !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
1718                 return;
1719
1720         if(adapter->smartspeed == 0) {
1721                 /* If Master/Slave config fault is asserted twice,
1722                  * we assume back-to-back */
1723                 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp);
1724                 if(!(phy_tmp & SR_1000T_MS_CONFIG_FAULT)) return;
1725                 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp);
1726                 if(phy_tmp & SR_1000T_MS_CONFIG_FAULT) {
1727                         em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL,
1728                                         &phy_tmp);
1729                         if(phy_tmp & CR_1000T_MS_ENABLE) {
1730                                 phy_tmp &= ~CR_1000T_MS_ENABLE;
1731                                 em_write_phy_reg(&adapter->hw,
1732                                                     PHY_1000T_CTRL, phy_tmp);
1733                                 adapter->smartspeed++;
1734                                 if(adapter->hw.autoneg &&
1735                                    !em_phy_setup_autoneg(&adapter->hw) &&
1736                                    !em_read_phy_reg(&adapter->hw, PHY_CTRL,
1737                                                        &phy_tmp)) {
1738                                         phy_tmp |= (MII_CR_AUTO_NEG_EN |
1739                                                     MII_CR_RESTART_AUTO_NEG);
1740                                         em_write_phy_reg(&adapter->hw,
1741                                                          PHY_CTRL, phy_tmp);
1742                                 }
1743                         }
1744                 }
1745                 return;
1746         } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) {
1747                 /* If still no link, perhaps using 2/3 pair cable */
1748                 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp);
1749                 phy_tmp |= CR_1000T_MS_ENABLE;
1750                 em_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp);
1751                 if(adapter->hw.autoneg &&
1752                    !em_phy_setup_autoneg(&adapter->hw) &&
1753                    !em_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_tmp)) {
1754                         phy_tmp |= (MII_CR_AUTO_NEG_EN |
1755                                     MII_CR_RESTART_AUTO_NEG);
1756                         em_write_phy_reg(&adapter->hw, PHY_CTRL, phy_tmp);
1757                 }
1758         }
1759         /* Restart process after EM_SMARTSPEED_MAX iterations */
1760         if(adapter->smartspeed++ == EM_SMARTSPEED_MAX)
1761                 adapter->smartspeed = 0;
1762
1763         return;
1764 }
1765
1766
1767 /*********************************************************************
1768  *
1769  *  Allocate memory for tx_buffer structures. The tx_buffer stores all
1770  *  the information needed to transmit a packet on the wire.
1771  *
1772  **********************************************************************/
1773 static int
1774 em_allocate_transmit_structures(struct adapter * adapter)
1775 {
1776         if (!(adapter->tx_buffer_area =
1777               (struct em_buffer *) malloc(sizeof(struct em_buffer) *
1778                                              adapter->num_tx_desc, M_DEVBUF,
1779                                              M_NOWAIT))) {
1780                 printf("em%d: Unable to allocate tx_buffer memory\n",
1781                        adapter->unit);
1782                 return ENOMEM;
1783         }
1784
1785         bzero(adapter->tx_buffer_area,
1786               sizeof(struct em_buffer) * adapter->num_tx_desc);
1787
1788         return 0;
1789 }
1790
1791 /*********************************************************************
1792  *
1793  *  Allocate and initialize transmit structures.
1794  *
1795  **********************************************************************/
1796 static int
1797 em_setup_transmit_structures(struct adapter * adapter)
1798 {
1799         if (em_allocate_transmit_structures(adapter))
1800                 return ENOMEM;
1801
1802         bzero((void *) adapter->tx_desc_base,
1803               (sizeof(struct em_tx_desc)) * adapter->num_tx_desc);
1804
1805         adapter->next_avail_tx_desc = 0;
1806         adapter->oldest_used_tx_desc = 0;
1807
1808         /* Set number of descriptors available */
1809         adapter->num_tx_desc_avail = adapter->num_tx_desc;
1810
1811         /* Set checksum context */
1812         adapter->active_checksum_context = OFFLOAD_NONE;
1813
1814         return 0;
1815 }
1816
1817 /*********************************************************************
1818  *
1819  *  Enable transmit unit.
1820  *
1821  **********************************************************************/
1822 static void
1823 em_initialize_transmit_unit(struct adapter * adapter)
1824 {
1825         u_int32_t       reg_tctl;
1826         u_int32_t       reg_tipg = 0;
1827         u_int64_t       tdba = vtophys((vm_offset_t)adapter->tx_desc_base);
1828
1829         /* Setup the Base and Length of the Tx Descriptor Ring */
1830         E1000_WRITE_REG(&adapter->hw, TDBAL,
1831                         (tdba & 0x00000000ffffffffULL));
1832         E1000_WRITE_REG(&adapter->hw, TDBAH, (tdba >> 32));
1833         E1000_WRITE_REG(&adapter->hw, TDLEN,
1834                         adapter->num_tx_desc *
1835                         sizeof(struct em_tx_desc));
1836
1837         /* Setup the HW Tx Head and Tail descriptor pointers */
1838         E1000_WRITE_REG(&adapter->hw, TDH, 0);
1839         E1000_WRITE_REG(&adapter->hw, TDT, 0);
1840
1841
1842         HW_DEBUGOUT2("Base = %x, Length = %x\n",
1843                      E1000_READ_REG(&adapter->hw, TDBAL),
1844                      E1000_READ_REG(&adapter->hw, TDLEN));
1845
1846
1847         /* Set the default values for the Tx Inter Packet Gap timer */
1848         switch (adapter->hw.mac_type) {
1849         case em_82542_rev2_0:
1850         case em_82542_rev2_1:
1851                 reg_tipg = DEFAULT_82542_TIPG_IPGT;
1852                 reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
1853                 reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
1854                 break;
1855         default:
1856                 if (adapter->hw.media_type == em_media_type_fiber)
1857                         reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
1858                 else
1859                         reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
1860                 reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
1861                 reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
1862         }
1863
1864         E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg);
1865         E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay);
1866         if(adapter->hw.mac_type >= em_82540)
1867                 E1000_WRITE_REG(&adapter->hw, TADV, adapter->tx_abs_int_delay);
1868
1869         /* Program the Transmit Control Register */
1870         reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN |
1871                    (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
1872         if (adapter->link_duplex == 1) {
1873                 reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
1874         } else {
1875                 reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT;
1876         }
1877         E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl);
1878
1879         /* Setup Transmit Descriptor Settings for this adapter */
1880         adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS;
1881
1882         if (adapter->tx_int_delay > 0)
1883                 adapter->txd_cmd |= E1000_TXD_CMD_IDE;
1884
1885         return;
1886 }
1887
1888 /*********************************************************************
1889  *
1890  *  Free all transmit related data structures.
1891  *
1892  **********************************************************************/
1893 static void
1894 em_free_transmit_structures(struct adapter * adapter)
1895 {
1896         struct em_buffer   *tx_buffer;
1897         int             i;
1898
1899         INIT_DEBUGOUT("free_transmit_structures: begin");
1900
1901         if (adapter->tx_buffer_area != NULL) {
1902                 tx_buffer = adapter->tx_buffer_area;
1903                 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) {
1904                         if (tx_buffer->m_head != NULL)
1905                                 m_freem(tx_buffer->m_head);
1906                         tx_buffer->m_head = NULL;
1907                 }
1908         }
1909         if (adapter->tx_buffer_area != NULL) {
1910                 free(adapter->tx_buffer_area, M_DEVBUF);
1911                 adapter->tx_buffer_area = NULL;
1912         }
1913         return;
1914 }
1915
1916 /*********************************************************************
1917  *
1918  *  The offload context needs to be set when we transfer the first
1919  *  packet of a particular protocol (TCP/UDP). We change the
1920  *  context only if the protocol type changes.
1921  *
1922  **********************************************************************/
1923 static void
1924 em_transmit_checksum_setup(struct adapter * adapter,
1925                            struct mbuf *mp,
1926                            u_int32_t *txd_upper,
1927                            u_int32_t *txd_lower)
1928 {
1929         struct em_context_desc *TXD;
1930         struct em_buffer *tx_buffer;
1931         int curr_txd;
1932
1933         if (mp->m_pkthdr.csum_flags) {
1934
1935                 if (mp->m_pkthdr.csum_flags & CSUM_TCP) {
1936                         *txd_upper = E1000_TXD_POPTS_TXSM << 8;
1937                         *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
1938                         if (adapter->active_checksum_context == OFFLOAD_TCP_IP)
1939                                 return;
1940                         else
1941                                 adapter->active_checksum_context = OFFLOAD_TCP_IP;
1942
1943                 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) {
1944                         *txd_upper = E1000_TXD_POPTS_TXSM << 8;
1945                         *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
1946                         if (adapter->active_checksum_context == OFFLOAD_UDP_IP)
1947                                 return;
1948                         else
1949                                 adapter->active_checksum_context = OFFLOAD_UDP_IP;
1950                 } else {
1951                         *txd_upper = 0;
1952                         *txd_lower = 0;
1953                         return;
1954                 }
1955         } else {
1956                 *txd_upper = 0;
1957                 *txd_lower = 0;
1958                 return;
1959         }
1960
1961         /* If we reach this point, the checksum offload context
1962          * needs to be reset.
1963          */
1964         curr_txd = adapter->next_avail_tx_desc;
1965         tx_buffer = &adapter->tx_buffer_area[curr_txd];
1966         TXD = (struct em_context_desc *) &adapter->tx_desc_base[curr_txd];
1967
1968         TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN;
1969         TXD->lower_setup.ip_fields.ipcso =
1970                 ETHER_HDR_LEN + offsetof(struct ip, ip_sum);
1971         TXD->lower_setup.ip_fields.ipcse =
1972                 ETHER_HDR_LEN + sizeof(struct ip) - 1;
1973
1974         TXD->upper_setup.tcp_fields.tucss =
1975                 ETHER_HDR_LEN + sizeof(struct ip);
1976         TXD->upper_setup.tcp_fields.tucse = 0;
1977
1978         if (adapter->active_checksum_context == OFFLOAD_TCP_IP) {
1979                 TXD->upper_setup.tcp_fields.tucso =
1980                         ETHER_HDR_LEN + sizeof(struct ip) +
1981                         offsetof(struct tcphdr, th_sum);
1982         } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) {
1983                 TXD->upper_setup.tcp_fields.tucso =
1984                         ETHER_HDR_LEN + sizeof(struct ip) +
1985                         offsetof(struct udphdr, uh_sum);
1986         }
1987
1988         TXD->tcp_seg_setup.data = 0;
1989         TXD->cmd_and_length = (adapter->txd_cmd | E1000_TXD_CMD_DEXT);
1990
1991         tx_buffer->m_head = NULL;
1992
1993         if (++curr_txd == adapter->num_tx_desc)
1994                 curr_txd = 0;
1995
1996         adapter->num_tx_desc_avail--;
1997         adapter->next_avail_tx_desc = curr_txd;
1998
1999         return;
2000 }
2001
2002 /**********************************************************************
2003  *
2004  *  Examine each tx_buffer in the used queue. If the hardware is done
2005  *  processing the packet then free associated resources. The
2006  *  tx_buffer is put back on the free queue.
2007  *
2008  **********************************************************************/
2009 static void
2010 em_clean_transmit_interrupts(struct adapter * adapter)
2011 {
2012         int s;
2013         int i, num_avail;
2014         struct em_buffer *tx_buffer;
2015         struct em_tx_desc   *tx_desc;
2016         struct ifnet   *ifp = &adapter->interface_data.ac_if;
2017
2018         if (adapter->num_tx_desc_avail == adapter->num_tx_desc)
2019                 return;
2020
2021         s = splimp();
2022 #ifdef DBG_STATS
2023         adapter->clean_tx_interrupts++;
2024 #endif
2025         num_avail = adapter->num_tx_desc_avail;
2026         i = adapter->oldest_used_tx_desc;
2027
2028         tx_buffer = &adapter->tx_buffer_area[i];
2029         tx_desc = &adapter->tx_desc_base[i];
2030
2031         while(tx_desc->upper.fields.status & E1000_TXD_STAT_DD) {
2032
2033                 tx_desc->upper.data = 0;
2034                 num_avail++;
2035
2036                 if (tx_buffer->m_head) {
2037                         ifp->if_opackets++;
2038                         m_freem(tx_buffer->m_head);
2039                         tx_buffer->m_head = NULL;
2040                 }
2041
2042                 if (++i == adapter->num_tx_desc)
2043                         i = 0;
2044
2045                 tx_buffer = &adapter->tx_buffer_area[i];
2046                 tx_desc = &adapter->tx_desc_base[i];
2047         }
2048
2049         adapter->oldest_used_tx_desc = i;
2050
2051         /*
2052          * If we have enough room, clear IFF_OACTIVE to tell the stack
2053          * that it is OK to send packets.
2054          * If there are no pending descriptors, clear the timeout. Otherwise,
2055          * if some descriptors have been freed, restart the timeout.
2056          */
2057         if (num_avail > EM_TX_CLEANUP_THRESHOLD) {
2058                 ifp->if_flags &= ~IFF_OACTIVE;
2059                 if (num_avail == adapter->num_tx_desc)
2060                         ifp->if_timer = 0;
2061                 else if (num_avail == adapter->num_tx_desc_avail)
2062                         ifp->if_timer = EM_TX_TIMEOUT;
2063         }
2064         adapter->num_tx_desc_avail = num_avail;
2065         splx(s);
2066         return;
2067 }
2068
2069 /*********************************************************************
2070  *
2071  *  Get a buffer from system mbuf buffer pool.
2072  *
2073  **********************************************************************/
2074 static int
2075 em_get_buf(int i, struct adapter *adapter,
2076            struct mbuf *nmp)
2077 {
2078         register struct mbuf    *mp = nmp;
2079         struct ifnet   *ifp;
2080
2081         ifp = &adapter->interface_data.ac_if;
2082
2083         if (mp == NULL) {
2084                 MGETHDR(mp, M_DONTWAIT, MT_DATA);
2085                 if (mp == NULL) {
2086                         adapter->mbuf_alloc_failed++;
2087                         return(ENOBUFS);
2088                 }
2089                 MCLGET(mp, M_DONTWAIT);
2090                 if ((mp->m_flags & M_EXT) == 0) {
2091                         m_freem(mp);
2092                         adapter->mbuf_cluster_failed++;
2093                         return(ENOBUFS);
2094                 }
2095                 mp->m_len = mp->m_pkthdr.len = MCLBYTES;
2096         } else {
2097                 mp->m_len = mp->m_pkthdr.len = MCLBYTES;
2098                 mp->m_data = mp->m_ext.ext_buf;
2099                 mp->m_next = NULL;
2100         }
2101
2102         if (ifp->if_mtu <= ETHERMTU) {
2103                 m_adj(mp, ETHER_ALIGN);
2104         }
2105
2106         adapter->rx_buffer_area[i].m_head = mp;
2107         adapter->rx_desc_base[i].buffer_addr =
2108                 vtophys(mtod(mp, vm_offset_t));
2109
2110         return(0);
2111 }
2112
2113 /*********************************************************************
2114  *
2115  *  Allocate memory for rx_buffer structures. Since we use one
2116  *  rx_buffer per received packet, the maximum number of rx_buffer's
2117  *  that we'll need is equal to the number of receive descriptors
2118  *  that we've allocated.
2119  *
2120  **********************************************************************/
2121 static int
2122 em_allocate_receive_structures(struct adapter * adapter)
2123 {
2124         int             i;
2125
2126         if (!(adapter->rx_buffer_area =
2127               (struct em_buffer *) malloc(sizeof(struct em_buffer) *
2128                                              adapter->num_rx_desc, M_DEVBUF,
2129                                              M_NOWAIT))) {
2130                 printf("em%d: Unable to allocate rx_buffer memory\n",
2131                        adapter->unit);
2132                 return(ENOMEM);
2133         }
2134
2135         bzero(adapter->rx_buffer_area,
2136               sizeof(struct em_buffer) * adapter->num_rx_desc);
2137
2138         for (i = 0; i < adapter->num_rx_desc; i++) {
2139                 if (em_get_buf(i, adapter, NULL) == ENOBUFS) {
2140                         adapter->rx_buffer_area[i].m_head = NULL;
2141                         adapter->rx_desc_base[i].buffer_addr = 0;
2142                         return(ENOBUFS);
2143                 }
2144         }
2145
2146         return(0);
2147 }
2148
2149 /*********************************************************************
2150  *
2151  *  Allocate and initialize receive structures.
2152  *
2153  **********************************************************************/
2154 static int
2155 em_setup_receive_structures(struct adapter * adapter)
2156 {
2157         bzero((void *) adapter->rx_desc_base,
2158               (sizeof(struct em_rx_desc)) * adapter->num_rx_desc);
2159
2160         if (em_allocate_receive_structures(adapter))
2161                 return ENOMEM;
2162
2163         /* Setup our descriptor pointers */
2164         adapter->next_rx_desc_to_check = 0;
2165         return(0);
2166 }
2167
2168 /*********************************************************************
2169  *
2170  *  Enable receive unit.
2171  *
2172  **********************************************************************/
2173 static void
2174 em_initialize_receive_unit(struct adapter * adapter)
2175 {
2176         u_int32_t       reg_rctl;
2177         u_int32_t       reg_rxcsum;
2178         struct ifnet    *ifp;
2179         u_int64_t       rdba = vtophys((vm_offset_t)adapter->rx_desc_base);
2180
2181         ifp = &adapter->interface_data.ac_if;
2182
2183         /* Make sure receives are disabled while setting up the descriptor ring */
2184         E1000_WRITE_REG(&adapter->hw, RCTL, 0);
2185
2186         /* Set the Receive Delay Timer Register */
2187         E1000_WRITE_REG(&adapter->hw, RDTR,
2188                         adapter->rx_int_delay | E1000_RDT_FPDB);
2189
2190         if(adapter->hw.mac_type >= em_82540) {
2191                 E1000_WRITE_REG(&adapter->hw, RADV, adapter->rx_abs_int_delay);
2192
2193                 /* Set the interrupt throttling rate.  Value is calculated
2194                  * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */
2195 #define MAX_INTS_PER_SEC        8000
2196 #define DEFAULT_ITR             1000000000/(MAX_INTS_PER_SEC * 256)
2197                 E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR);
2198         }
2199
2200         /* Setup the Base and Length of the Rx Descriptor Ring */
2201         E1000_WRITE_REG(&adapter->hw, RDBAL,
2202                         (rdba & 0x00000000ffffffffULL));
2203         E1000_WRITE_REG(&adapter->hw, RDBAH, (rdba >> 32));
2204         E1000_WRITE_REG(&adapter->hw, RDLEN,
2205                         adapter->num_rx_desc *
2206                         sizeof(struct em_rx_desc));
2207
2208         /* Setup the HW Rx Head and Tail Descriptor Pointers */
2209         E1000_WRITE_REG(&adapter->hw, RDH, 0);
2210         E1000_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1);
2211
2212         /* Setup the Receive Control Register */
2213         reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
2214                    E1000_RCTL_RDMTS_HALF |
2215                    (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT);
2216
2217         if (adapter->hw.tbi_compatibility_on == TRUE)
2218                 reg_rctl |= E1000_RCTL_SBP;
2219
2220
2221         switch (adapter->rx_buffer_len) {
2222         default:
2223         case EM_RXBUFFER_2048:
2224                 reg_rctl |= E1000_RCTL_SZ_2048;
2225                 break;
2226         case EM_RXBUFFER_4096:
2227                 reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
2228                 break;
2229         case EM_RXBUFFER_8192:
2230                 reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
2231                 break;
2232         case EM_RXBUFFER_16384:
2233                 reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
2234                 break;
2235         }
2236
2237         if (ifp->if_mtu > ETHERMTU)
2238                 reg_rctl |= E1000_RCTL_LPE;
2239
2240         /* Enable 82543 Receive Checksum Offload for TCP and UDP */
2241         if ((adapter->hw.mac_type >= em_82543) &&
2242             (ifp->if_capenable & IFCAP_RXCSUM)) {
2243                 reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM);
2244                 reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL);
2245                 E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum);
2246         }
2247
2248         /* Enable Receives */
2249         E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
2250
2251         return;
2252 }
2253
2254 /*********************************************************************
2255  *
2256  *  Free receive related data structures.
2257  *
2258  **********************************************************************/
2259 static void
2260 em_free_receive_structures(struct adapter *adapter)
2261 {
2262         struct em_buffer   *rx_buffer;
2263         int             i;
2264
2265         INIT_DEBUGOUT("free_receive_structures: begin");
2266
2267         if (adapter->rx_buffer_area != NULL) {
2268                 rx_buffer = adapter->rx_buffer_area;
2269                 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
2270                         if (rx_buffer->m_head != NULL)
2271                                 m_freem(rx_buffer->m_head);
2272                         rx_buffer->m_head = NULL;
2273                 }
2274         }
2275         if (adapter->rx_buffer_area != NULL) {
2276                 free(adapter->rx_buffer_area, M_DEVBUF);
2277                 adapter->rx_buffer_area = NULL;
2278         }
2279         return;
2280 }
2281
2282 /*********************************************************************
2283  *
2284  *  This routine executes in interrupt context. It replenishes
2285  *  the mbufs in the descriptor and sends data which has been
2286  *  dma'ed into host memory to upper layer.
2287  *
2288  *  We loop at most count times if count is > 0, or until done if
2289  *  count < 0.
2290  *
2291  *********************************************************************/
2292 static void
2293 em_process_receive_interrupts(struct adapter * adapter, int count)
2294 {
2295         struct ifnet        *ifp;
2296         struct mbuf         *mp;
2297 #if defined(__DragonFly__) || __FreeBSD_version < 500000
2298         struct ether_header *eh;
2299 #endif
2300         u_int8_t            accept_frame = 0;
2301         u_int8_t            eop = 0;
2302         u_int16_t           len;
2303         int                 i;
2304
2305         /* Pointer to the receive descriptor being examined. */
2306         struct em_rx_desc   *current_desc;
2307
2308         ifp = &adapter->interface_data.ac_if;
2309         i = adapter->next_rx_desc_to_check;
2310         current_desc = &adapter->rx_desc_base[i];
2311
2312         if (!((current_desc->status) & E1000_RXD_STAT_DD)) {
2313 #ifdef DBG_STATS
2314                 adapter->no_pkts_avail++;
2315 #endif
2316                 return;
2317         }
2318
2319         while ((current_desc->status & E1000_RXD_STAT_DD) && (count != 0)) {
2320
2321                 mp = adapter->rx_buffer_area[i].m_head;
2322
2323                 accept_frame = 1;
2324                 if (current_desc->status & E1000_RXD_STAT_EOP) {
2325                         count--;
2326                         eop = 1;
2327                         len = current_desc->length - ETHER_CRC_LEN;
2328                 } else {
2329                         eop = 0;
2330                         len = current_desc->length;
2331                 }
2332
2333                 if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
2334                         u_int8_t            last_byte;
2335                         u_int32_t           pkt_len = current_desc->length;
2336
2337                         if (adapter->fmp != NULL)
2338                                 pkt_len += adapter->fmp->m_pkthdr.len;
2339
2340                         last_byte = *(mtod(mp, caddr_t) +
2341                                       current_desc->length - 1);
2342
2343                         if (TBI_ACCEPT(&adapter->hw, current_desc->status,
2344                                        current_desc->errors,
2345                                        pkt_len, last_byte)) {
2346                                 em_tbi_adjust_stats(&adapter->hw,
2347                                                     &adapter->stats,
2348                                                     pkt_len,
2349                                                     adapter->hw.mac_addr);
2350                                 len--;
2351                         }
2352                         else {
2353                                 accept_frame = 0;
2354                         }
2355                 }
2356
2357                 if (accept_frame) {
2358
2359                         if (em_get_buf(i, adapter, NULL) == ENOBUFS) {
2360                                 adapter->dropped_pkts++;
2361                                 em_get_buf(i, adapter, mp);
2362                                 if (adapter->fmp != NULL)
2363                                         m_freem(adapter->fmp);
2364                                 adapter->fmp = NULL;
2365                                 adapter->lmp = NULL;
2366                                 break;
2367                         }
2368
2369                         /* Assign correct length to the current fragment */
2370                         mp->m_len = len;
2371
2372                         if (adapter->fmp == NULL) {
2373                                 mp->m_pkthdr.len = len;
2374                                 adapter->fmp = mp;       /* Store the first mbuf */
2375                                 adapter->lmp = mp;
2376                         } else {
2377                                 /* Chain mbuf's together */
2378                                 mp->m_flags &= ~M_PKTHDR;
2379                                 adapter->lmp->m_next = mp;
2380                                 adapter->lmp = adapter->lmp->m_next;
2381                                 adapter->fmp->m_pkthdr.len += len;
2382                         }
2383
2384                         if (eop) {
2385                                 adapter->fmp->m_pkthdr.rcvif = ifp;
2386                                 ifp->if_ipackets++;
2387
2388 #if defined(__DragonFly__) || __FreeBSD_version < 500000
2389                                 eh = mtod(adapter->fmp, struct ether_header *);
2390                                 /* Remove ethernet header from mbuf */
2391                                 m_adj(adapter->fmp, sizeof(struct ether_header));
2392                                 em_receive_checksum(adapter, current_desc,
2393                                                     adapter->fmp);
2394                                 if (current_desc->status & E1000_RXD_STAT_VP)
2395                                         VLAN_INPUT_TAG(eh, adapter->fmp,
2396                                                        (current_desc->special &
2397                                                         E1000_RXD_SPC_VLAN_MASK));
2398                                 else
2399                                         ether_input(ifp, eh, adapter->fmp);
2400 #else
2401
2402                                 em_receive_checksum(adapter, current_desc,
2403                                                     adapter->fmp);
2404                                 if (current_desc->status & E1000_RXD_STAT_VP)
2405                                         VLAN_INPUT_TAG(ifp, adapter->fmp,
2406                                                        (current_desc->special &
2407                                                         E1000_RXD_SPC_VLAN_MASK),
2408                                                        adapter->fmp = NULL);
2409
2410                                 if (adapter->fmp != NULL)
2411                                         (*ifp->if_input)(ifp, adapter->fmp);
2412 #endif
2413                                 adapter->fmp = NULL;
2414                                 adapter->lmp = NULL;
2415                         }
2416                 } else {
2417                         adapter->dropped_pkts++;
2418                         em_get_buf(i, adapter, mp);
2419                         if (adapter->fmp != NULL)
2420                                 m_freem(adapter->fmp);
2421                         adapter->fmp = NULL;
2422                         adapter->lmp = NULL;
2423                 }
2424
2425                 /* Zero out the receive descriptors status  */
2426                 current_desc->status = 0;
2427
2428                 /* Advance the E1000's Receive Queue #0  "Tail Pointer". */
2429                 E1000_WRITE_REG(&adapter->hw, RDT, i);
2430
2431                 /* Advance our pointers to the next descriptor */
2432                 if (++i == adapter->num_rx_desc) {
2433                         i = 0;
2434                         current_desc = adapter->rx_desc_base;
2435                 } else
2436                         current_desc++;
2437         }
2438         adapter->next_rx_desc_to_check = i;
2439         return;
2440 }
2441
2442 /*********************************************************************
2443  *
2444  *  Verify that the hardware indicated that the checksum is valid.
2445  *  Inform the stack about the status of checksum so that stack
2446  *  doesn't spend time verifying the checksum.
2447  *
2448  *********************************************************************/
2449 static void
2450 em_receive_checksum(struct adapter *adapter,
2451                     struct em_rx_desc *rx_desc,
2452                     struct mbuf *mp)
2453 {
2454         /* 82543 or newer only */
2455         if ((adapter->hw.mac_type < em_82543) ||
2456             /* Ignore Checksum bit is set */
2457             (rx_desc->status & E1000_RXD_STAT_IXSM)) {
2458                 mp->m_pkthdr.csum_flags = 0;
2459                 return;
2460         }
2461
2462         if (rx_desc->status & E1000_RXD_STAT_IPCS) {
2463                 /* Did it pass? */
2464                 if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) {
2465                         /* IP Checksum Good */
2466                         mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
2467                         mp->m_pkthdr.csum_flags |= CSUM_IP_VALID;
2468
2469                 } else {
2470                         mp->m_pkthdr.csum_flags = 0;
2471                 }
2472         }
2473
2474         if (rx_desc->status & E1000_RXD_STAT_TCPCS) {
2475                 /* Did it pass? */
2476                 if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) {
2477                         mp->m_pkthdr.csum_flags |=
2478                         (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
2479                         mp->m_pkthdr.csum_data = htons(0xffff);
2480                 }
2481         }
2482
2483         return;
2484 }
2485
2486
2487 static void
2488 em_enable_vlans(struct adapter *adapter)
2489 {
2490         uint32_t ctrl;
2491
2492         E1000_WRITE_REG(&adapter->hw, VET, ETHERTYPE_VLAN);
2493
2494         ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2495         ctrl |= E1000_CTRL_VME;
2496         E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2497
2498         return;
2499 }
2500
2501 static void
2502 em_enable_intr(struct adapter * adapter)
2503 {
2504         E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK));
2505         return;
2506 }
2507
2508 static void
2509 em_disable_intr(struct adapter *adapter)
2510 {
2511         E1000_WRITE_REG(&adapter->hw, IMC,
2512                         (0xffffffff & ~E1000_IMC_RXSEQ));
2513         return;
2514 }
2515
2516 static int
2517 em_is_valid_ether_addr(u_int8_t *addr)
2518 {
2519         char zero_addr[6] = { 0, 0, 0, 0, 0, 0 };
2520
2521         if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) {
2522                 return (FALSE);
2523         }
2524
2525         return(TRUE);
2526 }
2527
2528 void
2529 em_write_pci_cfg(struct em_hw *hw,
2530                       uint32_t reg,
2531                       uint16_t *value)
2532 {
2533         pci_write_config(((struct em_osdep *)hw->back)->dev, reg,
2534                          *value, 2);
2535 }
2536
2537 void
2538 em_read_pci_cfg(struct em_hw *hw, uint32_t reg,
2539                      uint16_t *value)
2540 {
2541         *value = pci_read_config(((struct em_osdep *)hw->back)->dev,
2542                                  reg, 2);
2543         return;
2544 }
2545
2546 void
2547 em_pci_set_mwi(struct em_hw *hw)
2548 {
2549         pci_write_config(((struct em_osdep *)hw->back)->dev,
2550                          PCIR_COMMAND,
2551                          (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2);
2552         return;
2553 }
2554
2555 void
2556 em_pci_clear_mwi(struct em_hw *hw)
2557 {
2558         pci_write_config(((struct em_osdep *)hw->back)->dev,
2559                          PCIR_COMMAND,
2560                          (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2);
2561         return;
2562 }
2563
2564 uint32_t
2565 em_io_read(struct em_hw *hw, uint32_t port)
2566 {
2567         return(inl(port));
2568 }
2569
2570 void
2571 em_io_write(struct em_hw *hw, uint32_t port, uint32_t value)
2572 {
2573         outl(port, value);
2574         return;
2575 }
2576
2577
2578 /**********************************************************************
2579  *
2580  *  Update the board statistics counters.
2581  *
2582  **********************************************************************/
2583 static void
2584 em_update_stats_counters(struct adapter *adapter)
2585 {
2586         struct ifnet   *ifp;
2587
2588         adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS);
2589         adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS);
2590         adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC);
2591         adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC);
2592         adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL);
2593
2594         adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC);
2595         adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL);
2596         adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC);
2597         adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC);
2598         adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC);
2599         adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC);
2600         adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC);
2601         adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC);
2602         adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC);
2603         adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC);
2604         adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC);
2605         adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64);
2606         adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127);
2607         adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255);
2608         adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511);
2609         adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023);
2610         adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522);
2611         adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC);
2612         adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC);
2613         adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC);
2614         adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC);
2615
2616         /* For the 64-bit byte counters the low dword must be read first. */
2617         /* Both registers clear on the read of the high dword */
2618
2619         adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL);
2620         adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH);
2621         adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL);
2622         adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH);
2623
2624         adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC);
2625         adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC);
2626         adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC);
2627         adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC);
2628         adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC);
2629
2630         adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL);
2631         adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH);
2632         adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL);
2633         adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH);
2634
2635         adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR);
2636         adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT);
2637         adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64);
2638         adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127);
2639         adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255);
2640         adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511);
2641         adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023);
2642         adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522);
2643         adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC);
2644         adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC);
2645
2646         if (adapter->hw.mac_type >= em_82543) {
2647                 adapter->stats.algnerrc +=
2648                 E1000_READ_REG(&adapter->hw, ALGNERRC);
2649                 adapter->stats.rxerrc +=
2650                 E1000_READ_REG(&adapter->hw, RXERRC);
2651                 adapter->stats.tncrs +=
2652                 E1000_READ_REG(&adapter->hw, TNCRS);
2653                 adapter->stats.cexterr +=
2654                 E1000_READ_REG(&adapter->hw, CEXTERR);
2655                 adapter->stats.tsctc +=
2656                 E1000_READ_REG(&adapter->hw, TSCTC);
2657                 adapter->stats.tsctfc +=
2658                 E1000_READ_REG(&adapter->hw, TSCTFC);
2659         }
2660         ifp = &adapter->interface_data.ac_if;
2661
2662         /* Fill out the OS statistics structure */
2663         ifp->if_ibytes = adapter->stats.gorcl;
2664         ifp->if_obytes = adapter->stats.gotcl;
2665         ifp->if_imcasts = adapter->stats.mprc;
2666         ifp->if_collisions = adapter->stats.colc;
2667
2668         /* Rx Errors */
2669         ifp->if_ierrors =
2670         adapter->dropped_pkts +
2671         adapter->stats.rxerrc +
2672         adapter->stats.crcerrs +
2673         adapter->stats.algnerrc +
2674         adapter->stats.rlec + adapter->stats.rnbc +
2675         adapter->stats.mpc + adapter->stats.cexterr;
2676
2677         /* Tx Errors */
2678         ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol;
2679
2680 }
2681
2682
2683 /**********************************************************************
2684  *
2685  *  This routine is called only when em_display_debug_stats is enabled.
2686  *  This routine provides a way to take a look at important statistics
2687  *  maintained by the driver and hardware.
2688  *
2689  **********************************************************************/
2690 static void
2691 em_print_debug_info(struct adapter *adapter)
2692 {
2693         int unit = adapter->unit;
2694
2695 #ifdef DBG_STATS
2696         printf("em%d: Packets not Avail = %ld\n", unit,
2697                adapter->no_pkts_avail);
2698         printf("em%d: CleanTxInterrupts = %ld\n", unit,
2699                adapter->clean_tx_interrupts);
2700 #endif
2701         printf("em%d: fifo workaround = %lld, fifo_reset = %lld\n", unit,
2702                (long long)adapter->tx_fifo_wrk,
2703                (long long)adapter->tx_fifo_reset);
2704         printf("em%d: hw tdh = %d, hw tdt = %d\n", unit,
2705                E1000_READ_REG(&adapter->hw, TDH),
2706                E1000_READ_REG(&adapter->hw, TDT));
2707         printf("em%d: Num Tx descriptors avail = %d\n", unit,
2708                adapter->num_tx_desc_avail);
2709         printf("em%d: Tx Descriptors not avail1 = %ld\n", unit,
2710                adapter->no_tx_desc_avail1);
2711         printf("em%d: Tx Descriptors not avail2 = %ld\n", unit,
2712                adapter->no_tx_desc_avail2);
2713         printf("em%d: Std mbuf failed = %ld\n", unit,
2714                adapter->mbuf_alloc_failed);
2715         printf("em%d: Std mbuf cluster failed = %ld\n", unit,
2716                adapter->mbuf_cluster_failed);
2717         printf("em%d: Driver dropped packets = %ld\n", unit,
2718                adapter->dropped_pkts);
2719
2720         return;
2721 }
2722
2723 static void
2724 em_print_hw_stats(struct adapter *adapter)
2725 {
2726         int unit = adapter->unit;
2727
2728         printf("em%d: Excessive collisions = %lld\n", unit,
2729                (long long)adapter->stats.ecol);
2730         printf("em%d: Symbol errors = %lld\n", unit,
2731                (long long)adapter->stats.symerrs);
2732         printf("em%d: Sequence errors = %lld\n", unit,
2733                (long long)adapter->stats.sec);
2734         printf("em%d: Defer count = %lld\n", unit,
2735                (long long)adapter->stats.dc);
2736
2737         printf("em%d: Missed Packets = %lld\n", unit,
2738                (long long)adapter->stats.mpc);
2739         printf("em%d: Receive No Buffers = %lld\n", unit,
2740                (long long)adapter->stats.rnbc);
2741         printf("em%d: Receive length errors = %lld\n", unit,
2742                (long long)adapter->stats.rlec);
2743         printf("em%d: Receive errors = %lld\n", unit,
2744                (long long)adapter->stats.rxerrc);
2745         printf("em%d: Crc errors = %lld\n", unit,
2746                (long long)adapter->stats.crcerrs);
2747         printf("em%d: Alignment errors = %lld\n", unit,
2748                (long long)adapter->stats.algnerrc);
2749         printf("em%d: Carrier extension errors = %lld\n", unit,
2750                (long long)adapter->stats.cexterr);
2751
2752         printf("em%d: XON Rcvd = %lld\n", unit,
2753                (long long)adapter->stats.xonrxc);
2754         printf("em%d: XON Xmtd = %lld\n", unit,
2755                (long long)adapter->stats.xontxc);
2756         printf("em%d: XOFF Rcvd = %lld\n", unit,
2757                (long long)adapter->stats.xoffrxc);
2758         printf("em%d: XOFF Xmtd = %lld\n", unit,
2759                (long long)adapter->stats.xofftxc);
2760
2761         printf("em%d: Good Packets Rcvd = %lld\n", unit,
2762                (long long)adapter->stats.gprc);
2763         printf("em%d: Good Packets Xmtd = %lld\n", unit,
2764                (long long)adapter->stats.gptc);
2765
2766         return;
2767 }
2768
2769 static int
2770 em_sysctl_debug_info(SYSCTL_HANDLER_ARGS)
2771 {
2772         int error;
2773         int result;
2774         struct adapter *adapter;
2775
2776         result = -1;
2777         error = sysctl_handle_int(oidp, &result, 0, req);
2778
2779         if (error || !req->newptr)
2780                 return (error);
2781
2782         if (result == 1) {
2783                 adapter = (struct adapter *)arg1;
2784                 em_print_debug_info(adapter);
2785         }
2786
2787         return error;
2788 }
2789
2790
2791 static int
2792 em_sysctl_stats(SYSCTL_HANDLER_ARGS)
2793 {
2794         int error;
2795         int result;
2796         struct adapter *adapter;
2797
2798         result = -1;
2799         error = sysctl_handle_int(oidp, &result, 0, req);
2800
2801         if (error || !req->newptr)
2802                 return (error);
2803
2804         if (result == 1) {
2805                 adapter = (struct adapter *)arg1;
2806                 em_print_hw_stats(adapter);
2807         }
2808
2809         return error;
2810 }
2811