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