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