1 /******************************************************************************* 2 3 Intel PRO/1000 Linux driver 4 Copyright(c) 1999 - 2006 Intel Corporation. 5 6 This program is free software; you can redistribute it and/or modify it 7 under the terms and conditions of the GNU General Public License, 8 version 2, as published by the Free Software Foundation. 9 10 This program is distributed in the hope it will be useful, but WITHOUT 11 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 more details. 14 15 You should have received a copy of the GNU General Public License along with 16 this program; if not, write to the Free Software Foundation, Inc., 17 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 18 19 The full GNU General Public License is included in this distribution in 20 the file called "COPYING". 21 22 Contact Information: 23 Linux NICS <linux.nics@intel.com> 24 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 25 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 26 27 *******************************************************************************/ 28 29 #include "e1000.h" 30 #include <net/ip6_checksum.h> 31 #include <linux/io.h> 32 #include <linux/prefetch.h> 33 #include <linux/bitops.h> 34 #include <linux/if_vlan.h> 35 36 char e1000_driver_name[] = "e1000"; 37 static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver"; 38 #define DRV_VERSION "7.3.21-k8-NAPI" 39 const char e1000_driver_version[] = DRV_VERSION; 40 static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation."; 41 42 /* e1000_pci_tbl - PCI Device ID Table 43 * 44 * Last entry must be all 0s 45 * 46 * Macro expands to... 47 * {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)} 48 */ 49 static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = { 50 INTEL_E1000_ETHERNET_DEVICE(0x1000), 51 INTEL_E1000_ETHERNET_DEVICE(0x1001), 52 INTEL_E1000_ETHERNET_DEVICE(0x1004), 53 INTEL_E1000_ETHERNET_DEVICE(0x1008), 54 INTEL_E1000_ETHERNET_DEVICE(0x1009), 55 INTEL_E1000_ETHERNET_DEVICE(0x100C), 56 INTEL_E1000_ETHERNET_DEVICE(0x100D), 57 INTEL_E1000_ETHERNET_DEVICE(0x100E), 58 INTEL_E1000_ETHERNET_DEVICE(0x100F), 59 INTEL_E1000_ETHERNET_DEVICE(0x1010), 60 INTEL_E1000_ETHERNET_DEVICE(0x1011), 61 INTEL_E1000_ETHERNET_DEVICE(0x1012), 62 INTEL_E1000_ETHERNET_DEVICE(0x1013), 63 INTEL_E1000_ETHERNET_DEVICE(0x1014), 64 INTEL_E1000_ETHERNET_DEVICE(0x1015), 65 INTEL_E1000_ETHERNET_DEVICE(0x1016), 66 INTEL_E1000_ETHERNET_DEVICE(0x1017), 67 INTEL_E1000_ETHERNET_DEVICE(0x1018), 68 INTEL_E1000_ETHERNET_DEVICE(0x1019), 69 INTEL_E1000_ETHERNET_DEVICE(0x101A), 70 INTEL_E1000_ETHERNET_DEVICE(0x101D), 71 INTEL_E1000_ETHERNET_DEVICE(0x101E), 72 INTEL_E1000_ETHERNET_DEVICE(0x1026), 73 INTEL_E1000_ETHERNET_DEVICE(0x1027), 74 INTEL_E1000_ETHERNET_DEVICE(0x1028), 75 INTEL_E1000_ETHERNET_DEVICE(0x1075), 76 INTEL_E1000_ETHERNET_DEVICE(0x1076), 77 INTEL_E1000_ETHERNET_DEVICE(0x1077), 78 INTEL_E1000_ETHERNET_DEVICE(0x1078), 79 INTEL_E1000_ETHERNET_DEVICE(0x1079), 80 INTEL_E1000_ETHERNET_DEVICE(0x107A), 81 INTEL_E1000_ETHERNET_DEVICE(0x107B), 82 INTEL_E1000_ETHERNET_DEVICE(0x107C), 83 INTEL_E1000_ETHERNET_DEVICE(0x108A), 84 INTEL_E1000_ETHERNET_DEVICE(0x1099), 85 INTEL_E1000_ETHERNET_DEVICE(0x10B5), 86 INTEL_E1000_ETHERNET_DEVICE(0x2E6E), 87 /* required last entry */ 88 {0,} 89 }; 90 91 MODULE_DEVICE_TABLE(pci, e1000_pci_tbl); 92 93 int e1000_up(struct e1000_adapter *adapter); 94 void e1000_down(struct e1000_adapter *adapter); 95 void e1000_reinit_locked(struct e1000_adapter *adapter); 96 void e1000_reset(struct e1000_adapter *adapter); 97 int e1000_setup_all_tx_resources(struct e1000_adapter *adapter); 98 int e1000_setup_all_rx_resources(struct e1000_adapter *adapter); 99 void e1000_free_all_tx_resources(struct e1000_adapter *adapter); 100 void e1000_free_all_rx_resources(struct e1000_adapter *adapter); 101 static int e1000_setup_tx_resources(struct e1000_adapter *adapter, 102 struct e1000_tx_ring *txdr); 103 static int e1000_setup_rx_resources(struct e1000_adapter *adapter, 104 struct e1000_rx_ring *rxdr); 105 static void e1000_free_tx_resources(struct e1000_adapter *adapter, 106 struct e1000_tx_ring *tx_ring); 107 static void e1000_free_rx_resources(struct e1000_adapter *adapter, 108 struct e1000_rx_ring *rx_ring); 109 void e1000_update_stats(struct e1000_adapter *adapter); 110 111 static int e1000_init_module(void); 112 static void e1000_exit_module(void); 113 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent); 114 static void e1000_remove(struct pci_dev *pdev); 115 static int e1000_alloc_queues(struct e1000_adapter *adapter); 116 static int e1000_sw_init(struct e1000_adapter *adapter); 117 static int e1000_open(struct net_device *netdev); 118 static int e1000_close(struct net_device *netdev); 119 static void e1000_configure_tx(struct e1000_adapter *adapter); 120 static void e1000_configure_rx(struct e1000_adapter *adapter); 121 static void e1000_setup_rctl(struct e1000_adapter *adapter); 122 static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter); 123 static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter); 124 static void e1000_clean_tx_ring(struct e1000_adapter *adapter, 125 struct e1000_tx_ring *tx_ring); 126 static void e1000_clean_rx_ring(struct e1000_adapter *adapter, 127 struct e1000_rx_ring *rx_ring); 128 static void e1000_set_rx_mode(struct net_device *netdev); 129 static void e1000_update_phy_info_task(struct work_struct *work); 130 static void e1000_watchdog(struct work_struct *work); 131 static void e1000_82547_tx_fifo_stall_task(struct work_struct *work); 132 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb, 133 struct net_device *netdev); 134 static struct net_device_stats * e1000_get_stats(struct net_device *netdev); 135 static int e1000_change_mtu(struct net_device *netdev, int new_mtu); 136 static int e1000_set_mac(struct net_device *netdev, void *p); 137 static irqreturn_t e1000_intr(int irq, void *data); 138 static bool e1000_clean_tx_irq(struct e1000_adapter *adapter, 139 struct e1000_tx_ring *tx_ring); 140 static int e1000_clean(struct napi_struct *napi, int budget); 141 static bool e1000_clean_rx_irq(struct e1000_adapter *adapter, 142 struct e1000_rx_ring *rx_ring, 143 int *work_done, int work_to_do); 144 static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter, 145 struct e1000_rx_ring *rx_ring, 146 int *work_done, int work_to_do); 147 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter, 148 struct e1000_rx_ring *rx_ring, 149 int cleaned_count); 150 static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter, 151 struct e1000_rx_ring *rx_ring, 152 int cleaned_count); 153 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd); 154 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr, 155 int cmd); 156 static void e1000_enter_82542_rst(struct e1000_adapter *adapter); 157 static void e1000_leave_82542_rst(struct e1000_adapter *adapter); 158 static void e1000_tx_timeout(struct net_device *dev); 159 static void e1000_reset_task(struct work_struct *work); 160 static void e1000_smartspeed(struct e1000_adapter *adapter); 161 static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter, 162 struct sk_buff *skb); 163 164 static bool e1000_vlan_used(struct e1000_adapter *adapter); 165 static void e1000_vlan_mode(struct net_device *netdev, 166 netdev_features_t features); 167 static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter, 168 bool filter_on); 169 static int e1000_vlan_rx_add_vid(struct net_device *netdev, 170 __be16 proto, u16 vid); 171 static int e1000_vlan_rx_kill_vid(struct net_device *netdev, 172 __be16 proto, u16 vid); 173 static void e1000_restore_vlan(struct e1000_adapter *adapter); 174 175 #ifdef CONFIG_PM 176 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state); 177 static int e1000_resume(struct pci_dev *pdev); 178 #endif 179 static void e1000_shutdown(struct pci_dev *pdev); 180 181 #ifdef CONFIG_NET_POLL_CONTROLLER 182 /* for netdump / net console */ 183 static void e1000_netpoll (struct net_device *netdev); 184 #endif 185 186 #define COPYBREAK_DEFAULT 256 187 static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT; 188 module_param(copybreak, uint, 0644); 189 MODULE_PARM_DESC(copybreak, 190 "Maximum size of packet that is copied to a new buffer on receive"); 191 192 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev, 193 pci_channel_state_t state); 194 static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev); 195 static void e1000_io_resume(struct pci_dev *pdev); 196 197 static const struct pci_error_handlers e1000_err_handler = { 198 .error_detected = e1000_io_error_detected, 199 .slot_reset = e1000_io_slot_reset, 200 .resume = e1000_io_resume, 201 }; 202 203 static struct pci_driver e1000_driver = { 204 .name = e1000_driver_name, 205 .id_table = e1000_pci_tbl, 206 .probe = e1000_probe, 207 .remove = e1000_remove, 208 #ifdef CONFIG_PM 209 /* Power Management Hooks */ 210 .suspend = e1000_suspend, 211 .resume = e1000_resume, 212 #endif 213 .shutdown = e1000_shutdown, 214 .err_handler = &e1000_err_handler 215 }; 216 217 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>"); 218 MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver"); 219 MODULE_LICENSE("GPL"); 220 MODULE_VERSION(DRV_VERSION); 221 222 #define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK) 223 static int debug = -1; 224 module_param(debug, int, 0); 225 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)"); 226 227 /** 228 * e1000_get_hw_dev - return device 229 * used by hardware layer to print debugging information 230 * 231 **/ 232 struct net_device *e1000_get_hw_dev(struct e1000_hw *hw) 233 { 234 struct e1000_adapter *adapter = hw->back; 235 return adapter->netdev; 236 } 237 238 /** 239 * e1000_init_module - Driver Registration Routine 240 * 241 * e1000_init_module is the first routine called when the driver is 242 * loaded. All it does is register with the PCI subsystem. 243 **/ 244 static int __init e1000_init_module(void) 245 { 246 int ret; 247 pr_info("%s - version %s\n", e1000_driver_string, e1000_driver_version); 248 249 pr_info("%s\n", e1000_copyright); 250 251 ret = pci_register_driver(&e1000_driver); 252 if (copybreak != COPYBREAK_DEFAULT) { 253 if (copybreak == 0) 254 pr_info("copybreak disabled\n"); 255 else 256 pr_info("copybreak enabled for " 257 "packets <= %u bytes\n", copybreak); 258 } 259 return ret; 260 } 261 262 module_init(e1000_init_module); 263 264 /** 265 * e1000_exit_module - Driver Exit Cleanup Routine 266 * 267 * e1000_exit_module is called just before the driver is removed 268 * from memory. 269 **/ 270 static void __exit e1000_exit_module(void) 271 { 272 pci_unregister_driver(&e1000_driver); 273 } 274 275 module_exit(e1000_exit_module); 276 277 static int e1000_request_irq(struct e1000_adapter *adapter) 278 { 279 struct net_device *netdev = adapter->netdev; 280 irq_handler_t handler = e1000_intr; 281 int irq_flags = IRQF_SHARED; 282 int err; 283 284 err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name, 285 netdev); 286 if (err) { 287 e_err(probe, "Unable to allocate interrupt Error: %d\n", err); 288 } 289 290 return err; 291 } 292 293 static void e1000_free_irq(struct e1000_adapter *adapter) 294 { 295 struct net_device *netdev = adapter->netdev; 296 297 free_irq(adapter->pdev->irq, netdev); 298 } 299 300 /** 301 * e1000_irq_disable - Mask off interrupt generation on the NIC 302 * @adapter: board private structure 303 **/ 304 static void e1000_irq_disable(struct e1000_adapter *adapter) 305 { 306 struct e1000_hw *hw = &adapter->hw; 307 308 ew32(IMC, ~0); 309 E1000_WRITE_FLUSH(); 310 synchronize_irq(adapter->pdev->irq); 311 } 312 313 /** 314 * e1000_irq_enable - Enable default interrupt generation settings 315 * @adapter: board private structure 316 **/ 317 static void e1000_irq_enable(struct e1000_adapter *adapter) 318 { 319 struct e1000_hw *hw = &adapter->hw; 320 321 ew32(IMS, IMS_ENABLE_MASK); 322 E1000_WRITE_FLUSH(); 323 } 324 325 static void e1000_update_mng_vlan(struct e1000_adapter *adapter) 326 { 327 struct e1000_hw *hw = &adapter->hw; 328 struct net_device *netdev = adapter->netdev; 329 u16 vid = hw->mng_cookie.vlan_id; 330 u16 old_vid = adapter->mng_vlan_id; 331 332 if (!e1000_vlan_used(adapter)) 333 return; 334 335 if (!test_bit(vid, adapter->active_vlans)) { 336 if (hw->mng_cookie.status & 337 E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) { 338 e1000_vlan_rx_add_vid(netdev, htons(ETH_P_8021Q), vid); 339 adapter->mng_vlan_id = vid; 340 } else { 341 adapter->mng_vlan_id = E1000_MNG_VLAN_NONE; 342 } 343 if ((old_vid != (u16)E1000_MNG_VLAN_NONE) && 344 (vid != old_vid) && 345 !test_bit(old_vid, adapter->active_vlans)) 346 e1000_vlan_rx_kill_vid(netdev, htons(ETH_P_8021Q), 347 old_vid); 348 } else { 349 adapter->mng_vlan_id = vid; 350 } 351 } 352 353 static void e1000_init_manageability(struct e1000_adapter *adapter) 354 { 355 struct e1000_hw *hw = &adapter->hw; 356 357 if (adapter->en_mng_pt) { 358 u32 manc = er32(MANC); 359 360 /* disable hardware interception of ARP */ 361 manc &= ~(E1000_MANC_ARP_EN); 362 363 ew32(MANC, manc); 364 } 365 } 366 367 static void e1000_release_manageability(struct e1000_adapter *adapter) 368 { 369 struct e1000_hw *hw = &adapter->hw; 370 371 if (adapter->en_mng_pt) { 372 u32 manc = er32(MANC); 373 374 /* re-enable hardware interception of ARP */ 375 manc |= E1000_MANC_ARP_EN; 376 377 ew32(MANC, manc); 378 } 379 } 380 381 /** 382 * e1000_configure - configure the hardware for RX and TX 383 * @adapter = private board structure 384 **/ 385 static void e1000_configure(struct e1000_adapter *adapter) 386 { 387 struct net_device *netdev = adapter->netdev; 388 int i; 389 390 e1000_set_rx_mode(netdev); 391 392 e1000_restore_vlan(adapter); 393 e1000_init_manageability(adapter); 394 395 e1000_configure_tx(adapter); 396 e1000_setup_rctl(adapter); 397 e1000_configure_rx(adapter); 398 /* call E1000_DESC_UNUSED which always leaves 399 * at least 1 descriptor unused to make sure 400 * next_to_use != next_to_clean 401 */ 402 for (i = 0; i < adapter->num_rx_queues; i++) { 403 struct e1000_rx_ring *ring = &adapter->rx_ring[i]; 404 adapter->alloc_rx_buf(adapter, ring, 405 E1000_DESC_UNUSED(ring)); 406 } 407 } 408 409 int e1000_up(struct e1000_adapter *adapter) 410 { 411 struct e1000_hw *hw = &adapter->hw; 412 413 /* hardware has been reset, we need to reload some things */ 414 e1000_configure(adapter); 415 416 clear_bit(__E1000_DOWN, &adapter->flags); 417 418 napi_enable(&adapter->napi); 419 420 e1000_irq_enable(adapter); 421 422 netif_wake_queue(adapter->netdev); 423 424 /* fire a link change interrupt to start the watchdog */ 425 ew32(ICS, E1000_ICS_LSC); 426 return 0; 427 } 428 429 /** 430 * e1000_power_up_phy - restore link in case the phy was powered down 431 * @adapter: address of board private structure 432 * 433 * The phy may be powered down to save power and turn off link when the 434 * driver is unloaded and wake on lan is not enabled (among others) 435 * *** this routine MUST be followed by a call to e1000_reset *** 436 **/ 437 void e1000_power_up_phy(struct e1000_adapter *adapter) 438 { 439 struct e1000_hw *hw = &adapter->hw; 440 u16 mii_reg = 0; 441 442 /* Just clear the power down bit to wake the phy back up */ 443 if (hw->media_type == e1000_media_type_copper) { 444 /* according to the manual, the phy will retain its 445 * settings across a power-down/up cycle 446 */ 447 e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg); 448 mii_reg &= ~MII_CR_POWER_DOWN; 449 e1000_write_phy_reg(hw, PHY_CTRL, mii_reg); 450 } 451 } 452 453 static void e1000_power_down_phy(struct e1000_adapter *adapter) 454 { 455 struct e1000_hw *hw = &adapter->hw; 456 457 /* Power down the PHY so no link is implied when interface is down * 458 * The PHY cannot be powered down if any of the following is true * 459 * (a) WoL is enabled 460 * (b) AMT is active 461 * (c) SoL/IDER session is active 462 */ 463 if (!adapter->wol && hw->mac_type >= e1000_82540 && 464 hw->media_type == e1000_media_type_copper) { 465 u16 mii_reg = 0; 466 467 switch (hw->mac_type) { 468 case e1000_82540: 469 case e1000_82545: 470 case e1000_82545_rev_3: 471 case e1000_82546: 472 case e1000_ce4100: 473 case e1000_82546_rev_3: 474 case e1000_82541: 475 case e1000_82541_rev_2: 476 case e1000_82547: 477 case e1000_82547_rev_2: 478 if (er32(MANC) & E1000_MANC_SMBUS_EN) 479 goto out; 480 break; 481 default: 482 goto out; 483 } 484 e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg); 485 mii_reg |= MII_CR_POWER_DOWN; 486 e1000_write_phy_reg(hw, PHY_CTRL, mii_reg); 487 msleep(1); 488 } 489 out: 490 return; 491 } 492 493 static void e1000_down_and_stop(struct e1000_adapter *adapter) 494 { 495 set_bit(__E1000_DOWN, &adapter->flags); 496 497 cancel_delayed_work_sync(&adapter->watchdog_task); 498 499 /* 500 * Since the watchdog task can reschedule other tasks, we should cancel 501 * it first, otherwise we can run into the situation when a work is 502 * still running after the adapter has been turned down. 503 */ 504 505 cancel_delayed_work_sync(&adapter->phy_info_task); 506 cancel_delayed_work_sync(&adapter->fifo_stall_task); 507 508 /* Only kill reset task if adapter is not resetting */ 509 if (!test_bit(__E1000_RESETTING, &adapter->flags)) 510 cancel_work_sync(&adapter->reset_task); 511 } 512 513 void e1000_down(struct e1000_adapter *adapter) 514 { 515 struct e1000_hw *hw = &adapter->hw; 516 struct net_device *netdev = adapter->netdev; 517 u32 rctl, tctl; 518 519 520 /* disable receives in the hardware */ 521 rctl = er32(RCTL); 522 ew32(RCTL, rctl & ~E1000_RCTL_EN); 523 /* flush and sleep below */ 524 525 netif_tx_disable(netdev); 526 527 /* disable transmits in the hardware */ 528 tctl = er32(TCTL); 529 tctl &= ~E1000_TCTL_EN; 530 ew32(TCTL, tctl); 531 /* flush both disables and wait for them to finish */ 532 E1000_WRITE_FLUSH(); 533 msleep(10); 534 535 napi_disable(&adapter->napi); 536 537 e1000_irq_disable(adapter); 538 539 /* Setting DOWN must be after irq_disable to prevent 540 * a screaming interrupt. Setting DOWN also prevents 541 * tasks from rescheduling. 542 */ 543 e1000_down_and_stop(adapter); 544 545 adapter->link_speed = 0; 546 adapter->link_duplex = 0; 547 netif_carrier_off(netdev); 548 549 e1000_reset(adapter); 550 e1000_clean_all_tx_rings(adapter); 551 e1000_clean_all_rx_rings(adapter); 552 } 553 554 void e1000_reinit_locked(struct e1000_adapter *adapter) 555 { 556 WARN_ON(in_interrupt()); 557 while (test_and_set_bit(__E1000_RESETTING, &adapter->flags)) 558 msleep(1); 559 e1000_down(adapter); 560 e1000_up(adapter); 561 clear_bit(__E1000_RESETTING, &adapter->flags); 562 } 563 564 void e1000_reset(struct e1000_adapter *adapter) 565 { 566 struct e1000_hw *hw = &adapter->hw; 567 u32 pba = 0, tx_space, min_tx_space, min_rx_space; 568 bool legacy_pba_adjust = false; 569 u16 hwm; 570 571 /* Repartition Pba for greater than 9k mtu 572 * To take effect CTRL.RST is required. 573 */ 574 575 switch (hw->mac_type) { 576 case e1000_82542_rev2_0: 577 case e1000_82542_rev2_1: 578 case e1000_82543: 579 case e1000_82544: 580 case e1000_82540: 581 case e1000_82541: 582 case e1000_82541_rev_2: 583 legacy_pba_adjust = true; 584 pba = E1000_PBA_48K; 585 break; 586 case e1000_82545: 587 case e1000_82545_rev_3: 588 case e1000_82546: 589 case e1000_ce4100: 590 case e1000_82546_rev_3: 591 pba = E1000_PBA_48K; 592 break; 593 case e1000_82547: 594 case e1000_82547_rev_2: 595 legacy_pba_adjust = true; 596 pba = E1000_PBA_30K; 597 break; 598 case e1000_undefined: 599 case e1000_num_macs: 600 break; 601 } 602 603 if (legacy_pba_adjust) { 604 if (hw->max_frame_size > E1000_RXBUFFER_8192) 605 pba -= 8; /* allocate more FIFO for Tx */ 606 607 if (hw->mac_type == e1000_82547) { 608 adapter->tx_fifo_head = 0; 609 adapter->tx_head_addr = pba << E1000_TX_HEAD_ADDR_SHIFT; 610 adapter->tx_fifo_size = 611 (E1000_PBA_40K - pba) << E1000_PBA_BYTES_SHIFT; 612 atomic_set(&adapter->tx_fifo_stall, 0); 613 } 614 } else if (hw->max_frame_size > ETH_FRAME_LEN + ETH_FCS_LEN) { 615 /* adjust PBA for jumbo frames */ 616 ew32(PBA, pba); 617 618 /* To maintain wire speed transmits, the Tx FIFO should be 619 * large enough to accommodate two full transmit packets, 620 * rounded up to the next 1KB and expressed in KB. Likewise, 621 * the Rx FIFO should be large enough to accommodate at least 622 * one full receive packet and is similarly rounded up and 623 * expressed in KB. 624 */ 625 pba = er32(PBA); 626 /* upper 16 bits has Tx packet buffer allocation size in KB */ 627 tx_space = pba >> 16; 628 /* lower 16 bits has Rx packet buffer allocation size in KB */ 629 pba &= 0xffff; 630 /* the Tx fifo also stores 16 bytes of information about the Tx 631 * but don't include ethernet FCS because hardware appends it 632 */ 633 min_tx_space = (hw->max_frame_size + 634 sizeof(struct e1000_tx_desc) - 635 ETH_FCS_LEN) * 2; 636 min_tx_space = ALIGN(min_tx_space, 1024); 637 min_tx_space >>= 10; 638 /* software strips receive CRC, so leave room for it */ 639 min_rx_space = hw->max_frame_size; 640 min_rx_space = ALIGN(min_rx_space, 1024); 641 min_rx_space >>= 10; 642 643 /* If current Tx allocation is less than the min Tx FIFO size, 644 * and the min Tx FIFO size is less than the current Rx FIFO 645 * allocation, take space away from current Rx allocation 646 */ 647 if (tx_space < min_tx_space && 648 ((min_tx_space - tx_space) < pba)) { 649 pba = pba - (min_tx_space - tx_space); 650 651 /* PCI/PCIx hardware has PBA alignment constraints */ 652 switch (hw->mac_type) { 653 case e1000_82545 ... e1000_82546_rev_3: 654 pba &= ~(E1000_PBA_8K - 1); 655 break; 656 default: 657 break; 658 } 659 660 /* if short on Rx space, Rx wins and must trump Tx 661 * adjustment or use Early Receive if available 662 */ 663 if (pba < min_rx_space) 664 pba = min_rx_space; 665 } 666 } 667 668 ew32(PBA, pba); 669 670 /* flow control settings: 671 * The high water mark must be low enough to fit one full frame 672 * (or the size used for early receive) above it in the Rx FIFO. 673 * Set it to the lower of: 674 * - 90% of the Rx FIFO size, and 675 * - the full Rx FIFO size minus the early receive size (for parts 676 * with ERT support assuming ERT set to E1000_ERT_2048), or 677 * - the full Rx FIFO size minus one full frame 678 */ 679 hwm = min(((pba << 10) * 9 / 10), 680 ((pba << 10) - hw->max_frame_size)); 681 682 hw->fc_high_water = hwm & 0xFFF8; /* 8-byte granularity */ 683 hw->fc_low_water = hw->fc_high_water - 8; 684 hw->fc_pause_time = E1000_FC_PAUSE_TIME; 685 hw->fc_send_xon = 1; 686 hw->fc = hw->original_fc; 687 688 /* Allow time for pending master requests to run */ 689 e1000_reset_hw(hw); 690 if (hw->mac_type >= e1000_82544) 691 ew32(WUC, 0); 692 693 if (e1000_init_hw(hw)) 694 e_dev_err("Hardware Error\n"); 695 e1000_update_mng_vlan(adapter); 696 697 /* if (adapter->hwflags & HWFLAGS_PHY_PWR_BIT) { */ 698 if (hw->mac_type >= e1000_82544 && 699 hw->autoneg == 1 && 700 hw->autoneg_advertised == ADVERTISE_1000_FULL) { 701 u32 ctrl = er32(CTRL); 702 /* clear phy power management bit if we are in gig only mode, 703 * which if enabled will attempt negotiation to 100Mb, which 704 * can cause a loss of link at power off or driver unload 705 */ 706 ctrl &= ~E1000_CTRL_SWDPIN3; 707 ew32(CTRL, ctrl); 708 } 709 710 /* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */ 711 ew32(VET, ETHERNET_IEEE_VLAN_TYPE); 712 713 e1000_reset_adaptive(hw); 714 e1000_phy_get_info(hw, &adapter->phy_info); 715 716 e1000_release_manageability(adapter); 717 } 718 719 /* Dump the eeprom for users having checksum issues */ 720 static void e1000_dump_eeprom(struct e1000_adapter *adapter) 721 { 722 struct net_device *netdev = adapter->netdev; 723 struct ethtool_eeprom eeprom; 724 const struct ethtool_ops *ops = netdev->ethtool_ops; 725 u8 *data; 726 int i; 727 u16 csum_old, csum_new = 0; 728 729 eeprom.len = ops->get_eeprom_len(netdev); 730 eeprom.offset = 0; 731 732 data = kmalloc(eeprom.len, GFP_KERNEL); 733 if (!data) 734 return; 735 736 ops->get_eeprom(netdev, &eeprom, data); 737 738 csum_old = (data[EEPROM_CHECKSUM_REG * 2]) + 739 (data[EEPROM_CHECKSUM_REG * 2 + 1] << 8); 740 for (i = 0; i < EEPROM_CHECKSUM_REG * 2; i += 2) 741 csum_new += data[i] + (data[i + 1] << 8); 742 csum_new = EEPROM_SUM - csum_new; 743 744 pr_err("/*********************/\n"); 745 pr_err("Current EEPROM Checksum : 0x%04x\n", csum_old); 746 pr_err("Calculated : 0x%04x\n", csum_new); 747 748 pr_err("Offset Values\n"); 749 pr_err("======== ======\n"); 750 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 16, 1, data, 128, 0); 751 752 pr_err("Include this output when contacting your support provider.\n"); 753 pr_err("This is not a software error! Something bad happened to\n"); 754 pr_err("your hardware or EEPROM image. Ignoring this problem could\n"); 755 pr_err("result in further problems, possibly loss of data,\n"); 756 pr_err("corruption or system hangs!\n"); 757 pr_err("The MAC Address will be reset to 00:00:00:00:00:00,\n"); 758 pr_err("which is invalid and requires you to set the proper MAC\n"); 759 pr_err("address manually before continuing to enable this network\n"); 760 pr_err("device. Please inspect the EEPROM dump and report the\n"); 761 pr_err("issue to your hardware vendor or Intel Customer Support.\n"); 762 pr_err("/*********************/\n"); 763 764 kfree(data); 765 } 766 767 /** 768 * e1000_is_need_ioport - determine if an adapter needs ioport resources or not 769 * @pdev: PCI device information struct 770 * 771 * Return true if an adapter needs ioport resources 772 **/ 773 static int e1000_is_need_ioport(struct pci_dev *pdev) 774 { 775 switch (pdev->device) { 776 case E1000_DEV_ID_82540EM: 777 case E1000_DEV_ID_82540EM_LOM: 778 case E1000_DEV_ID_82540EP: 779 case E1000_DEV_ID_82540EP_LOM: 780 case E1000_DEV_ID_82540EP_LP: 781 case E1000_DEV_ID_82541EI: 782 case E1000_DEV_ID_82541EI_MOBILE: 783 case E1000_DEV_ID_82541ER: 784 case E1000_DEV_ID_82541ER_LOM: 785 case E1000_DEV_ID_82541GI: 786 case E1000_DEV_ID_82541GI_LF: 787 case E1000_DEV_ID_82541GI_MOBILE: 788 case E1000_DEV_ID_82544EI_COPPER: 789 case E1000_DEV_ID_82544EI_FIBER: 790 case E1000_DEV_ID_82544GC_COPPER: 791 case E1000_DEV_ID_82544GC_LOM: 792 case E1000_DEV_ID_82545EM_COPPER: 793 case E1000_DEV_ID_82545EM_FIBER: 794 case E1000_DEV_ID_82546EB_COPPER: 795 case E1000_DEV_ID_82546EB_FIBER: 796 case E1000_DEV_ID_82546EB_QUAD_COPPER: 797 return true; 798 default: 799 return false; 800 } 801 } 802 803 static netdev_features_t e1000_fix_features(struct net_device *netdev, 804 netdev_features_t features) 805 { 806 /* Since there is no support for separate Rx/Tx vlan accel 807 * enable/disable make sure Tx flag is always in same state as Rx. 808 */ 809 if (features & NETIF_F_HW_VLAN_CTAG_RX) 810 features |= NETIF_F_HW_VLAN_CTAG_TX; 811 else 812 features &= ~NETIF_F_HW_VLAN_CTAG_TX; 813 814 return features; 815 } 816 817 static int e1000_set_features(struct net_device *netdev, 818 netdev_features_t features) 819 { 820 struct e1000_adapter *adapter = netdev_priv(netdev); 821 netdev_features_t changed = features ^ netdev->features; 822 823 if (changed & NETIF_F_HW_VLAN_CTAG_RX) 824 e1000_vlan_mode(netdev, features); 825 826 if (!(changed & (NETIF_F_RXCSUM | NETIF_F_RXALL))) 827 return 0; 828 829 netdev->features = features; 830 adapter->rx_csum = !!(features & NETIF_F_RXCSUM); 831 832 if (netif_running(netdev)) 833 e1000_reinit_locked(adapter); 834 else 835 e1000_reset(adapter); 836 837 return 0; 838 } 839 840 static const struct net_device_ops e1000_netdev_ops = { 841 .ndo_open = e1000_open, 842 .ndo_stop = e1000_close, 843 .ndo_start_xmit = e1000_xmit_frame, 844 .ndo_get_stats = e1000_get_stats, 845 .ndo_set_rx_mode = e1000_set_rx_mode, 846 .ndo_set_mac_address = e1000_set_mac, 847 .ndo_tx_timeout = e1000_tx_timeout, 848 .ndo_change_mtu = e1000_change_mtu, 849 .ndo_do_ioctl = e1000_ioctl, 850 .ndo_validate_addr = eth_validate_addr, 851 .ndo_vlan_rx_add_vid = e1000_vlan_rx_add_vid, 852 .ndo_vlan_rx_kill_vid = e1000_vlan_rx_kill_vid, 853 #ifdef CONFIG_NET_POLL_CONTROLLER 854 .ndo_poll_controller = e1000_netpoll, 855 #endif 856 .ndo_fix_features = e1000_fix_features, 857 .ndo_set_features = e1000_set_features, 858 }; 859 860 /** 861 * e1000_init_hw_struct - initialize members of hw struct 862 * @adapter: board private struct 863 * @hw: structure used by e1000_hw.c 864 * 865 * Factors out initialization of the e1000_hw struct to its own function 866 * that can be called very early at init (just after struct allocation). 867 * Fields are initialized based on PCI device information and 868 * OS network device settings (MTU size). 869 * Returns negative error codes if MAC type setup fails. 870 */ 871 static int e1000_init_hw_struct(struct e1000_adapter *adapter, 872 struct e1000_hw *hw) 873 { 874 struct pci_dev *pdev = adapter->pdev; 875 876 /* PCI config space info */ 877 hw->vendor_id = pdev->vendor; 878 hw->device_id = pdev->device; 879 hw->subsystem_vendor_id = pdev->subsystem_vendor; 880 hw->subsystem_id = pdev->subsystem_device; 881 hw->revision_id = pdev->revision; 882 883 pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word); 884 885 hw->max_frame_size = adapter->netdev->mtu + 886 ENET_HEADER_SIZE + ETHERNET_FCS_SIZE; 887 hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE; 888 889 /* identify the MAC */ 890 if (e1000_set_mac_type(hw)) { 891 e_err(probe, "Unknown MAC Type\n"); 892 return -EIO; 893 } 894 895 switch (hw->mac_type) { 896 default: 897 break; 898 case e1000_82541: 899 case e1000_82547: 900 case e1000_82541_rev_2: 901 case e1000_82547_rev_2: 902 hw->phy_init_script = 1; 903 break; 904 } 905 906 e1000_set_media_type(hw); 907 e1000_get_bus_info(hw); 908 909 hw->wait_autoneg_complete = false; 910 hw->tbi_compatibility_en = true; 911 hw->adaptive_ifs = true; 912 913 /* Copper options */ 914 915 if (hw->media_type == e1000_media_type_copper) { 916 hw->mdix = AUTO_ALL_MODES; 917 hw->disable_polarity_correction = false; 918 hw->master_slave = E1000_MASTER_SLAVE; 919 } 920 921 return 0; 922 } 923 924 /** 925 * e1000_probe - Device Initialization Routine 926 * @pdev: PCI device information struct 927 * @ent: entry in e1000_pci_tbl 928 * 929 * Returns 0 on success, negative on failure 930 * 931 * e1000_probe initializes an adapter identified by a pci_dev structure. 932 * The OS initialization, configuring of the adapter private structure, 933 * and a hardware reset occur. 934 **/ 935 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 936 { 937 struct net_device *netdev; 938 struct e1000_adapter *adapter; 939 struct e1000_hw *hw; 940 941 static int cards_found = 0; 942 static int global_quad_port_a = 0; /* global ksp3 port a indication */ 943 int i, err, pci_using_dac; 944 u16 eeprom_data = 0; 945 u16 tmp = 0; 946 u16 eeprom_apme_mask = E1000_EEPROM_APME; 947 int bars, need_ioport; 948 949 /* do not allocate ioport bars when not needed */ 950 need_ioport = e1000_is_need_ioport(pdev); 951 if (need_ioport) { 952 bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO); 953 err = pci_enable_device(pdev); 954 } else { 955 bars = pci_select_bars(pdev, IORESOURCE_MEM); 956 err = pci_enable_device_mem(pdev); 957 } 958 if (err) 959 return err; 960 961 err = pci_request_selected_regions(pdev, bars, e1000_driver_name); 962 if (err) 963 goto err_pci_reg; 964 965 pci_set_master(pdev); 966 err = pci_save_state(pdev); 967 if (err) 968 goto err_alloc_etherdev; 969 970 err = -ENOMEM; 971 netdev = alloc_etherdev(sizeof(struct e1000_adapter)); 972 if (!netdev) 973 goto err_alloc_etherdev; 974 975 SET_NETDEV_DEV(netdev, &pdev->dev); 976 977 pci_set_drvdata(pdev, netdev); 978 adapter = netdev_priv(netdev); 979 adapter->netdev = netdev; 980 adapter->pdev = pdev; 981 adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE); 982 adapter->bars = bars; 983 adapter->need_ioport = need_ioport; 984 985 hw = &adapter->hw; 986 hw->back = adapter; 987 988 err = -EIO; 989 hw->hw_addr = pci_ioremap_bar(pdev, BAR_0); 990 if (!hw->hw_addr) 991 goto err_ioremap; 992 993 if (adapter->need_ioport) { 994 for (i = BAR_1; i <= BAR_5; i++) { 995 if (pci_resource_len(pdev, i) == 0) 996 continue; 997 if (pci_resource_flags(pdev, i) & IORESOURCE_IO) { 998 hw->io_base = pci_resource_start(pdev, i); 999 break; 1000 } 1001 } 1002 } 1003 1004 /* make ready for any if (hw->...) below */ 1005 err = e1000_init_hw_struct(adapter, hw); 1006 if (err) 1007 goto err_sw_init; 1008 1009 /* there is a workaround being applied below that limits 1010 * 64-bit DMA addresses to 64-bit hardware. There are some 1011 * 32-bit adapters that Tx hang when given 64-bit DMA addresses 1012 */ 1013 pci_using_dac = 0; 1014 if ((hw->bus_type == e1000_bus_type_pcix) && 1015 !dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64))) { 1016 pci_using_dac = 1; 1017 } else { 1018 err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 1019 if (err) { 1020 pr_err("No usable DMA config, aborting\n"); 1021 goto err_dma; 1022 } 1023 } 1024 1025 netdev->netdev_ops = &e1000_netdev_ops; 1026 e1000_set_ethtool_ops(netdev); 1027 netdev->watchdog_timeo = 5 * HZ; 1028 netif_napi_add(netdev, &adapter->napi, e1000_clean, 64); 1029 1030 strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1); 1031 1032 adapter->bd_number = cards_found; 1033 1034 /* setup the private structure */ 1035 1036 err = e1000_sw_init(adapter); 1037 if (err) 1038 goto err_sw_init; 1039 1040 err = -EIO; 1041 if (hw->mac_type == e1000_ce4100) { 1042 hw->ce4100_gbe_mdio_base_virt = 1043 ioremap(pci_resource_start(pdev, BAR_1), 1044 pci_resource_len(pdev, BAR_1)); 1045 1046 if (!hw->ce4100_gbe_mdio_base_virt) 1047 goto err_mdio_ioremap; 1048 } 1049 1050 if (hw->mac_type >= e1000_82543) { 1051 netdev->hw_features = NETIF_F_SG | 1052 NETIF_F_HW_CSUM | 1053 NETIF_F_HW_VLAN_CTAG_RX; 1054 netdev->features = NETIF_F_HW_VLAN_CTAG_TX | 1055 NETIF_F_HW_VLAN_CTAG_FILTER; 1056 } 1057 1058 if ((hw->mac_type >= e1000_82544) && 1059 (hw->mac_type != e1000_82547)) 1060 netdev->hw_features |= NETIF_F_TSO; 1061 1062 netdev->priv_flags |= IFF_SUPP_NOFCS; 1063 1064 netdev->features |= netdev->hw_features; 1065 netdev->hw_features |= (NETIF_F_RXCSUM | 1066 NETIF_F_RXALL | 1067 NETIF_F_RXFCS); 1068 1069 if (pci_using_dac) { 1070 netdev->features |= NETIF_F_HIGHDMA; 1071 netdev->vlan_features |= NETIF_F_HIGHDMA; 1072 } 1073 1074 netdev->vlan_features |= (NETIF_F_TSO | 1075 NETIF_F_HW_CSUM | 1076 NETIF_F_SG); 1077 1078 netdev->priv_flags |= IFF_UNICAST_FLT; 1079 1080 adapter->en_mng_pt = e1000_enable_mng_pass_thru(hw); 1081 1082 /* initialize eeprom parameters */ 1083 if (e1000_init_eeprom_params(hw)) { 1084 e_err(probe, "EEPROM initialization failed\n"); 1085 goto err_eeprom; 1086 } 1087 1088 /* before reading the EEPROM, reset the controller to 1089 * put the device in a known good starting state 1090 */ 1091 1092 e1000_reset_hw(hw); 1093 1094 /* make sure the EEPROM is good */ 1095 if (e1000_validate_eeprom_checksum(hw) < 0) { 1096 e_err(probe, "The EEPROM Checksum Is Not Valid\n"); 1097 e1000_dump_eeprom(adapter); 1098 /* set MAC address to all zeroes to invalidate and temporary 1099 * disable this device for the user. This blocks regular 1100 * traffic while still permitting ethtool ioctls from reaching 1101 * the hardware as well as allowing the user to run the 1102 * interface after manually setting a hw addr using 1103 * `ip set address` 1104 */ 1105 memset(hw->mac_addr, 0, netdev->addr_len); 1106 } else { 1107 /* copy the MAC address out of the EEPROM */ 1108 if (e1000_read_mac_addr(hw)) 1109 e_err(probe, "EEPROM Read Error\n"); 1110 } 1111 /* don't block initalization here due to bad MAC address */ 1112 memcpy(netdev->dev_addr, hw->mac_addr, netdev->addr_len); 1113 1114 if (!is_valid_ether_addr(netdev->dev_addr)) 1115 e_err(probe, "Invalid MAC Address\n"); 1116 1117 1118 INIT_DELAYED_WORK(&adapter->watchdog_task, e1000_watchdog); 1119 INIT_DELAYED_WORK(&adapter->fifo_stall_task, 1120 e1000_82547_tx_fifo_stall_task); 1121 INIT_DELAYED_WORK(&adapter->phy_info_task, e1000_update_phy_info_task); 1122 INIT_WORK(&adapter->reset_task, e1000_reset_task); 1123 1124 e1000_check_options(adapter); 1125 1126 /* Initial Wake on LAN setting 1127 * If APM wake is enabled in the EEPROM, 1128 * enable the ACPI Magic Packet filter 1129 */ 1130 1131 switch (hw->mac_type) { 1132 case e1000_82542_rev2_0: 1133 case e1000_82542_rev2_1: 1134 case e1000_82543: 1135 break; 1136 case e1000_82544: 1137 e1000_read_eeprom(hw, 1138 EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data); 1139 eeprom_apme_mask = E1000_EEPROM_82544_APM; 1140 break; 1141 case e1000_82546: 1142 case e1000_82546_rev_3: 1143 if (er32(STATUS) & E1000_STATUS_FUNC_1){ 1144 e1000_read_eeprom(hw, 1145 EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data); 1146 break; 1147 } 1148 /* Fall Through */ 1149 default: 1150 e1000_read_eeprom(hw, 1151 EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data); 1152 break; 1153 } 1154 if (eeprom_data & eeprom_apme_mask) 1155 adapter->eeprom_wol |= E1000_WUFC_MAG; 1156 1157 /* now that we have the eeprom settings, apply the special cases 1158 * where the eeprom may be wrong or the board simply won't support 1159 * wake on lan on a particular port 1160 */ 1161 switch (pdev->device) { 1162 case E1000_DEV_ID_82546GB_PCIE: 1163 adapter->eeprom_wol = 0; 1164 break; 1165 case E1000_DEV_ID_82546EB_FIBER: 1166 case E1000_DEV_ID_82546GB_FIBER: 1167 /* Wake events only supported on port A for dual fiber 1168 * regardless of eeprom setting 1169 */ 1170 if (er32(STATUS) & E1000_STATUS_FUNC_1) 1171 adapter->eeprom_wol = 0; 1172 break; 1173 case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3: 1174 /* if quad port adapter, disable WoL on all but port A */ 1175 if (global_quad_port_a != 0) 1176 adapter->eeprom_wol = 0; 1177 else 1178 adapter->quad_port_a = true; 1179 /* Reset for multiple quad port adapters */ 1180 if (++global_quad_port_a == 4) 1181 global_quad_port_a = 0; 1182 break; 1183 } 1184 1185 /* initialize the wol settings based on the eeprom settings */ 1186 adapter->wol = adapter->eeprom_wol; 1187 device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol); 1188 1189 /* Auto detect PHY address */ 1190 if (hw->mac_type == e1000_ce4100) { 1191 for (i = 0; i < 32; i++) { 1192 hw->phy_addr = i; 1193 e1000_read_phy_reg(hw, PHY_ID2, &tmp); 1194 if (tmp == 0 || tmp == 0xFF) { 1195 if (i == 31) 1196 goto err_eeprom; 1197 continue; 1198 } else 1199 break; 1200 } 1201 } 1202 1203 /* reset the hardware with the new settings */ 1204 e1000_reset(adapter); 1205 1206 strcpy(netdev->name, "eth%d"); 1207 err = register_netdev(netdev); 1208 if (err) 1209 goto err_register; 1210 1211 e1000_vlan_filter_on_off(adapter, false); 1212 1213 /* print bus type/speed/width info */ 1214 e_info(probe, "(PCI%s:%dMHz:%d-bit) %pM\n", 1215 ((hw->bus_type == e1000_bus_type_pcix) ? "-X" : ""), 1216 ((hw->bus_speed == e1000_bus_speed_133) ? 133 : 1217 (hw->bus_speed == e1000_bus_speed_120) ? 120 : 1218 (hw->bus_speed == e1000_bus_speed_100) ? 100 : 1219 (hw->bus_speed == e1000_bus_speed_66) ? 66 : 33), 1220 ((hw->bus_width == e1000_bus_width_64) ? 64 : 32), 1221 netdev->dev_addr); 1222 1223 /* carrier off reporting is important to ethtool even BEFORE open */ 1224 netif_carrier_off(netdev); 1225 1226 e_info(probe, "Intel(R) PRO/1000 Network Connection\n"); 1227 1228 cards_found++; 1229 return 0; 1230 1231 err_register: 1232 err_eeprom: 1233 e1000_phy_hw_reset(hw); 1234 1235 if (hw->flash_address) 1236 iounmap(hw->flash_address); 1237 kfree(adapter->tx_ring); 1238 kfree(adapter->rx_ring); 1239 err_dma: 1240 err_sw_init: 1241 err_mdio_ioremap: 1242 iounmap(hw->ce4100_gbe_mdio_base_virt); 1243 iounmap(hw->hw_addr); 1244 err_ioremap: 1245 free_netdev(netdev); 1246 err_alloc_etherdev: 1247 pci_release_selected_regions(pdev, bars); 1248 err_pci_reg: 1249 pci_disable_device(pdev); 1250 return err; 1251 } 1252 1253 /** 1254 * e1000_remove - Device Removal Routine 1255 * @pdev: PCI device information struct 1256 * 1257 * e1000_remove is called by the PCI subsystem to alert the driver 1258 * that it should release a PCI device. The could be caused by a 1259 * Hot-Plug event, or because the driver is going to be removed from 1260 * memory. 1261 **/ 1262 static void e1000_remove(struct pci_dev *pdev) 1263 { 1264 struct net_device *netdev = pci_get_drvdata(pdev); 1265 struct e1000_adapter *adapter = netdev_priv(netdev); 1266 struct e1000_hw *hw = &adapter->hw; 1267 1268 e1000_down_and_stop(adapter); 1269 e1000_release_manageability(adapter); 1270 1271 unregister_netdev(netdev); 1272 1273 e1000_phy_hw_reset(hw); 1274 1275 kfree(adapter->tx_ring); 1276 kfree(adapter->rx_ring); 1277 1278 if (hw->mac_type == e1000_ce4100) 1279 iounmap(hw->ce4100_gbe_mdio_base_virt); 1280 iounmap(hw->hw_addr); 1281 if (hw->flash_address) 1282 iounmap(hw->flash_address); 1283 pci_release_selected_regions(pdev, adapter->bars); 1284 1285 free_netdev(netdev); 1286 1287 pci_disable_device(pdev); 1288 } 1289 1290 /** 1291 * e1000_sw_init - Initialize general software structures (struct e1000_adapter) 1292 * @adapter: board private structure to initialize 1293 * 1294 * e1000_sw_init initializes the Adapter private data structure. 1295 * e1000_init_hw_struct MUST be called before this function 1296 **/ 1297 static int e1000_sw_init(struct e1000_adapter *adapter) 1298 { 1299 adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE; 1300 1301 adapter->num_tx_queues = 1; 1302 adapter->num_rx_queues = 1; 1303 1304 if (e1000_alloc_queues(adapter)) { 1305 e_err(probe, "Unable to allocate memory for queues\n"); 1306 return -ENOMEM; 1307 } 1308 1309 /* Explicitly disable IRQ since the NIC can be in any state. */ 1310 e1000_irq_disable(adapter); 1311 1312 spin_lock_init(&adapter->stats_lock); 1313 1314 set_bit(__E1000_DOWN, &adapter->flags); 1315 1316 return 0; 1317 } 1318 1319 /** 1320 * e1000_alloc_queues - Allocate memory for all rings 1321 * @adapter: board private structure to initialize 1322 * 1323 * We allocate one ring per queue at run-time since we don't know the 1324 * number of queues at compile-time. 1325 **/ 1326 static int e1000_alloc_queues(struct e1000_adapter *adapter) 1327 { 1328 adapter->tx_ring = kcalloc(adapter->num_tx_queues, 1329 sizeof(struct e1000_tx_ring), GFP_KERNEL); 1330 if (!adapter->tx_ring) 1331 return -ENOMEM; 1332 1333 adapter->rx_ring = kcalloc(adapter->num_rx_queues, 1334 sizeof(struct e1000_rx_ring), GFP_KERNEL); 1335 if (!adapter->rx_ring) { 1336 kfree(adapter->tx_ring); 1337 return -ENOMEM; 1338 } 1339 1340 return E1000_SUCCESS; 1341 } 1342 1343 /** 1344 * e1000_open - Called when a network interface is made active 1345 * @netdev: network interface device structure 1346 * 1347 * Returns 0 on success, negative value on failure 1348 * 1349 * The open entry point is called when a network interface is made 1350 * active by the system (IFF_UP). At this point all resources needed 1351 * for transmit and receive operations are allocated, the interrupt 1352 * handler is registered with the OS, the watchdog task is started, 1353 * and the stack is notified that the interface is ready. 1354 **/ 1355 static int e1000_open(struct net_device *netdev) 1356 { 1357 struct e1000_adapter *adapter = netdev_priv(netdev); 1358 struct e1000_hw *hw = &adapter->hw; 1359 int err; 1360 1361 /* disallow open during test */ 1362 if (test_bit(__E1000_TESTING, &adapter->flags)) 1363 return -EBUSY; 1364 1365 netif_carrier_off(netdev); 1366 1367 /* allocate transmit descriptors */ 1368 err = e1000_setup_all_tx_resources(adapter); 1369 if (err) 1370 goto err_setup_tx; 1371 1372 /* allocate receive descriptors */ 1373 err = e1000_setup_all_rx_resources(adapter); 1374 if (err) 1375 goto err_setup_rx; 1376 1377 e1000_power_up_phy(adapter); 1378 1379 adapter->mng_vlan_id = E1000_MNG_VLAN_NONE; 1380 if ((hw->mng_cookie.status & 1381 E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) { 1382 e1000_update_mng_vlan(adapter); 1383 } 1384 1385 /* before we allocate an interrupt, we must be ready to handle it. 1386 * Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt 1387 * as soon as we call pci_request_irq, so we have to setup our 1388 * clean_rx handler before we do so. 1389 */ 1390 e1000_configure(adapter); 1391 1392 err = e1000_request_irq(adapter); 1393 if (err) 1394 goto err_req_irq; 1395 1396 /* From here on the code is the same as e1000_up() */ 1397 clear_bit(__E1000_DOWN, &adapter->flags); 1398 1399 napi_enable(&adapter->napi); 1400 1401 e1000_irq_enable(adapter); 1402 1403 netif_start_queue(netdev); 1404 1405 /* fire a link status change interrupt to start the watchdog */ 1406 ew32(ICS, E1000_ICS_LSC); 1407 1408 return E1000_SUCCESS; 1409 1410 err_req_irq: 1411 e1000_power_down_phy(adapter); 1412 e1000_free_all_rx_resources(adapter); 1413 err_setup_rx: 1414 e1000_free_all_tx_resources(adapter); 1415 err_setup_tx: 1416 e1000_reset(adapter); 1417 1418 return err; 1419 } 1420 1421 /** 1422 * e1000_close - Disables a network interface 1423 * @netdev: network interface device structure 1424 * 1425 * Returns 0, this is not allowed to fail 1426 * 1427 * The close entry point is called when an interface is de-activated 1428 * by the OS. The hardware is still under the drivers control, but 1429 * needs to be disabled. A global MAC reset is issued to stop the 1430 * hardware, and all transmit and receive resources are freed. 1431 **/ 1432 static int e1000_close(struct net_device *netdev) 1433 { 1434 struct e1000_adapter *adapter = netdev_priv(netdev); 1435 struct e1000_hw *hw = &adapter->hw; 1436 int count = E1000_CHECK_RESET_COUNT; 1437 1438 while (test_bit(__E1000_RESETTING, &adapter->flags) && count--) 1439 usleep_range(10000, 20000); 1440 1441 WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags)); 1442 e1000_down(adapter); 1443 e1000_power_down_phy(adapter); 1444 e1000_free_irq(adapter); 1445 1446 e1000_free_all_tx_resources(adapter); 1447 e1000_free_all_rx_resources(adapter); 1448 1449 /* kill manageability vlan ID if supported, but not if a vlan with 1450 * the same ID is registered on the host OS (let 8021q kill it) 1451 */ 1452 if ((hw->mng_cookie.status & 1453 E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) && 1454 !test_bit(adapter->mng_vlan_id, adapter->active_vlans)) { 1455 e1000_vlan_rx_kill_vid(netdev, htons(ETH_P_8021Q), 1456 adapter->mng_vlan_id); 1457 } 1458 1459 return 0; 1460 } 1461 1462 /** 1463 * e1000_check_64k_bound - check that memory doesn't cross 64kB boundary 1464 * @adapter: address of board private structure 1465 * @start: address of beginning of memory 1466 * @len: length of memory 1467 **/ 1468 static bool e1000_check_64k_bound(struct e1000_adapter *adapter, void *start, 1469 unsigned long len) 1470 { 1471 struct e1000_hw *hw = &adapter->hw; 1472 unsigned long begin = (unsigned long)start; 1473 unsigned long end = begin + len; 1474 1475 /* First rev 82545 and 82546 need to not allow any memory 1476 * write location to cross 64k boundary due to errata 23 1477 */ 1478 if (hw->mac_type == e1000_82545 || 1479 hw->mac_type == e1000_ce4100 || 1480 hw->mac_type == e1000_82546) { 1481 return ((begin ^ (end - 1)) >> 16) != 0 ? false : true; 1482 } 1483 1484 return true; 1485 } 1486 1487 /** 1488 * e1000_setup_tx_resources - allocate Tx resources (Descriptors) 1489 * @adapter: board private structure 1490 * @txdr: tx descriptor ring (for a specific queue) to setup 1491 * 1492 * Return 0 on success, negative on failure 1493 **/ 1494 static int e1000_setup_tx_resources(struct e1000_adapter *adapter, 1495 struct e1000_tx_ring *txdr) 1496 { 1497 struct pci_dev *pdev = adapter->pdev; 1498 int size; 1499 1500 size = sizeof(struct e1000_buffer) * txdr->count; 1501 txdr->buffer_info = vzalloc(size); 1502 if (!txdr->buffer_info) 1503 return -ENOMEM; 1504 1505 /* round up to nearest 4K */ 1506 1507 txdr->size = txdr->count * sizeof(struct e1000_tx_desc); 1508 txdr->size = ALIGN(txdr->size, 4096); 1509 1510 txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma, 1511 GFP_KERNEL); 1512 if (!txdr->desc) { 1513 setup_tx_desc_die: 1514 vfree(txdr->buffer_info); 1515 return -ENOMEM; 1516 } 1517 1518 /* Fix for errata 23, can't cross 64kB boundary */ 1519 if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) { 1520 void *olddesc = txdr->desc; 1521 dma_addr_t olddma = txdr->dma; 1522 e_err(tx_err, "txdr align check failed: %u bytes at %p\n", 1523 txdr->size, txdr->desc); 1524 /* Try again, without freeing the previous */ 1525 txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, 1526 &txdr->dma, GFP_KERNEL); 1527 /* Failed allocation, critical failure */ 1528 if (!txdr->desc) { 1529 dma_free_coherent(&pdev->dev, txdr->size, olddesc, 1530 olddma); 1531 goto setup_tx_desc_die; 1532 } 1533 1534 if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) { 1535 /* give up */ 1536 dma_free_coherent(&pdev->dev, txdr->size, txdr->desc, 1537 txdr->dma); 1538 dma_free_coherent(&pdev->dev, txdr->size, olddesc, 1539 olddma); 1540 e_err(probe, "Unable to allocate aligned memory " 1541 "for the transmit descriptor ring\n"); 1542 vfree(txdr->buffer_info); 1543 return -ENOMEM; 1544 } else { 1545 /* Free old allocation, new allocation was successful */ 1546 dma_free_coherent(&pdev->dev, txdr->size, olddesc, 1547 olddma); 1548 } 1549 } 1550 memset(txdr->desc, 0, txdr->size); 1551 1552 txdr->next_to_use = 0; 1553 txdr->next_to_clean = 0; 1554 1555 return 0; 1556 } 1557 1558 /** 1559 * e1000_setup_all_tx_resources - wrapper to allocate Tx resources 1560 * (Descriptors) for all queues 1561 * @adapter: board private structure 1562 * 1563 * Return 0 on success, negative on failure 1564 **/ 1565 int e1000_setup_all_tx_resources(struct e1000_adapter *adapter) 1566 { 1567 int i, err = 0; 1568 1569 for (i = 0; i < adapter->num_tx_queues; i++) { 1570 err = e1000_setup_tx_resources(adapter, &adapter->tx_ring[i]); 1571 if (err) { 1572 e_err(probe, "Allocation for Tx Queue %u failed\n", i); 1573 for (i-- ; i >= 0; i--) 1574 e1000_free_tx_resources(adapter, 1575 &adapter->tx_ring[i]); 1576 break; 1577 } 1578 } 1579 1580 return err; 1581 } 1582 1583 /** 1584 * e1000_configure_tx - Configure 8254x Transmit Unit after Reset 1585 * @adapter: board private structure 1586 * 1587 * Configure the Tx unit of the MAC after a reset. 1588 **/ 1589 static void e1000_configure_tx(struct e1000_adapter *adapter) 1590 { 1591 u64 tdba; 1592 struct e1000_hw *hw = &adapter->hw; 1593 u32 tdlen, tctl, tipg; 1594 u32 ipgr1, ipgr2; 1595 1596 /* Setup the HW Tx Head and Tail descriptor pointers */ 1597 1598 switch (adapter->num_tx_queues) { 1599 case 1: 1600 default: 1601 tdba = adapter->tx_ring[0].dma; 1602 tdlen = adapter->tx_ring[0].count * 1603 sizeof(struct e1000_tx_desc); 1604 ew32(TDLEN, tdlen); 1605 ew32(TDBAH, (tdba >> 32)); 1606 ew32(TDBAL, (tdba & 0x00000000ffffffffULL)); 1607 ew32(TDT, 0); 1608 ew32(TDH, 0); 1609 adapter->tx_ring[0].tdh = ((hw->mac_type >= e1000_82543) ? 1610 E1000_TDH : E1000_82542_TDH); 1611 adapter->tx_ring[0].tdt = ((hw->mac_type >= e1000_82543) ? 1612 E1000_TDT : E1000_82542_TDT); 1613 break; 1614 } 1615 1616 /* Set the default values for the Tx Inter Packet Gap timer */ 1617 if ((hw->media_type == e1000_media_type_fiber || 1618 hw->media_type == e1000_media_type_internal_serdes)) 1619 tipg = DEFAULT_82543_TIPG_IPGT_FIBER; 1620 else 1621 tipg = DEFAULT_82543_TIPG_IPGT_COPPER; 1622 1623 switch (hw->mac_type) { 1624 case e1000_82542_rev2_0: 1625 case e1000_82542_rev2_1: 1626 tipg = DEFAULT_82542_TIPG_IPGT; 1627 ipgr1 = DEFAULT_82542_TIPG_IPGR1; 1628 ipgr2 = DEFAULT_82542_TIPG_IPGR2; 1629 break; 1630 default: 1631 ipgr1 = DEFAULT_82543_TIPG_IPGR1; 1632 ipgr2 = DEFAULT_82543_TIPG_IPGR2; 1633 break; 1634 } 1635 tipg |= ipgr1 << E1000_TIPG_IPGR1_SHIFT; 1636 tipg |= ipgr2 << E1000_TIPG_IPGR2_SHIFT; 1637 ew32(TIPG, tipg); 1638 1639 /* Set the Tx Interrupt Delay register */ 1640 1641 ew32(TIDV, adapter->tx_int_delay); 1642 if (hw->mac_type >= e1000_82540) 1643 ew32(TADV, adapter->tx_abs_int_delay); 1644 1645 /* Program the Transmit Control Register */ 1646 1647 tctl = er32(TCTL); 1648 tctl &= ~E1000_TCTL_CT; 1649 tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC | 1650 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT); 1651 1652 e1000_config_collision_dist(hw); 1653 1654 /* Setup Transmit Descriptor Settings for eop descriptor */ 1655 adapter->txd_cmd = E1000_TXD_CMD_EOP | E1000_TXD_CMD_IFCS; 1656 1657 /* only set IDE if we are delaying interrupts using the timers */ 1658 if (adapter->tx_int_delay) 1659 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 1660 1661 if (hw->mac_type < e1000_82543) 1662 adapter->txd_cmd |= E1000_TXD_CMD_RPS; 1663 else 1664 adapter->txd_cmd |= E1000_TXD_CMD_RS; 1665 1666 /* Cache if we're 82544 running in PCI-X because we'll 1667 * need this to apply a workaround later in the send path. 1668 */ 1669 if (hw->mac_type == e1000_82544 && 1670 hw->bus_type == e1000_bus_type_pcix) 1671 adapter->pcix_82544 = true; 1672 1673 ew32(TCTL, tctl); 1674 1675 } 1676 1677 /** 1678 * e1000_setup_rx_resources - allocate Rx resources (Descriptors) 1679 * @adapter: board private structure 1680 * @rxdr: rx descriptor ring (for a specific queue) to setup 1681 * 1682 * Returns 0 on success, negative on failure 1683 **/ 1684 static int e1000_setup_rx_resources(struct e1000_adapter *adapter, 1685 struct e1000_rx_ring *rxdr) 1686 { 1687 struct pci_dev *pdev = adapter->pdev; 1688 int size, desc_len; 1689 1690 size = sizeof(struct e1000_buffer) * rxdr->count; 1691 rxdr->buffer_info = vzalloc(size); 1692 if (!rxdr->buffer_info) 1693 return -ENOMEM; 1694 1695 desc_len = sizeof(struct e1000_rx_desc); 1696 1697 /* Round up to nearest 4K */ 1698 1699 rxdr->size = rxdr->count * desc_len; 1700 rxdr->size = ALIGN(rxdr->size, 4096); 1701 1702 rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma, 1703 GFP_KERNEL); 1704 if (!rxdr->desc) { 1705 setup_rx_desc_die: 1706 vfree(rxdr->buffer_info); 1707 return -ENOMEM; 1708 } 1709 1710 /* Fix for errata 23, can't cross 64kB boundary */ 1711 if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) { 1712 void *olddesc = rxdr->desc; 1713 dma_addr_t olddma = rxdr->dma; 1714 e_err(rx_err, "rxdr align check failed: %u bytes at %p\n", 1715 rxdr->size, rxdr->desc); 1716 /* Try again, without freeing the previous */ 1717 rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, 1718 &rxdr->dma, GFP_KERNEL); 1719 /* Failed allocation, critical failure */ 1720 if (!rxdr->desc) { 1721 dma_free_coherent(&pdev->dev, rxdr->size, olddesc, 1722 olddma); 1723 goto setup_rx_desc_die; 1724 } 1725 1726 if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) { 1727 /* give up */ 1728 dma_free_coherent(&pdev->dev, rxdr->size, rxdr->desc, 1729 rxdr->dma); 1730 dma_free_coherent(&pdev->dev, rxdr->size, olddesc, 1731 olddma); 1732 e_err(probe, "Unable to allocate aligned memory for " 1733 "the Rx descriptor ring\n"); 1734 goto setup_rx_desc_die; 1735 } else { 1736 /* Free old allocation, new allocation was successful */ 1737 dma_free_coherent(&pdev->dev, rxdr->size, olddesc, 1738 olddma); 1739 } 1740 } 1741 memset(rxdr->desc, 0, rxdr->size); 1742 1743 rxdr->next_to_clean = 0; 1744 rxdr->next_to_use = 0; 1745 rxdr->rx_skb_top = NULL; 1746 1747 return 0; 1748 } 1749 1750 /** 1751 * e1000_setup_all_rx_resources - wrapper to allocate Rx resources 1752 * (Descriptors) for all queues 1753 * @adapter: board private structure 1754 * 1755 * Return 0 on success, negative on failure 1756 **/ 1757 int e1000_setup_all_rx_resources(struct e1000_adapter *adapter) 1758 { 1759 int i, err = 0; 1760 1761 for (i = 0; i < adapter->num_rx_queues; i++) { 1762 err = e1000_setup_rx_resources(adapter, &adapter->rx_ring[i]); 1763 if (err) { 1764 e_err(probe, "Allocation for Rx Queue %u failed\n", i); 1765 for (i-- ; i >= 0; i--) 1766 e1000_free_rx_resources(adapter, 1767 &adapter->rx_ring[i]); 1768 break; 1769 } 1770 } 1771 1772 return err; 1773 } 1774 1775 /** 1776 * e1000_setup_rctl - configure the receive control registers 1777 * @adapter: Board private structure 1778 **/ 1779 static void e1000_setup_rctl(struct e1000_adapter *adapter) 1780 { 1781 struct e1000_hw *hw = &adapter->hw; 1782 u32 rctl; 1783 1784 rctl = er32(RCTL); 1785 1786 rctl &= ~(3 << E1000_RCTL_MO_SHIFT); 1787 1788 rctl |= E1000_RCTL_BAM | E1000_RCTL_LBM_NO | 1789 E1000_RCTL_RDMTS_HALF | 1790 (hw->mc_filter_type << E1000_RCTL_MO_SHIFT); 1791 1792 if (hw->tbi_compatibility_on == 1) 1793 rctl |= E1000_RCTL_SBP; 1794 else 1795 rctl &= ~E1000_RCTL_SBP; 1796 1797 if (adapter->netdev->mtu <= ETH_DATA_LEN) 1798 rctl &= ~E1000_RCTL_LPE; 1799 else 1800 rctl |= E1000_RCTL_LPE; 1801 1802 /* Setup buffer sizes */ 1803 rctl &= ~E1000_RCTL_SZ_4096; 1804 rctl |= E1000_RCTL_BSEX; 1805 switch (adapter->rx_buffer_len) { 1806 case E1000_RXBUFFER_2048: 1807 default: 1808 rctl |= E1000_RCTL_SZ_2048; 1809 rctl &= ~E1000_RCTL_BSEX; 1810 break; 1811 case E1000_RXBUFFER_4096: 1812 rctl |= E1000_RCTL_SZ_4096; 1813 break; 1814 case E1000_RXBUFFER_8192: 1815 rctl |= E1000_RCTL_SZ_8192; 1816 break; 1817 case E1000_RXBUFFER_16384: 1818 rctl |= E1000_RCTL_SZ_16384; 1819 break; 1820 } 1821 1822 /* This is useful for sniffing bad packets. */ 1823 if (adapter->netdev->features & NETIF_F_RXALL) { 1824 /* UPE and MPE will be handled by normal PROMISC logic 1825 * in e1000e_set_rx_mode 1826 */ 1827 rctl |= (E1000_RCTL_SBP | /* Receive bad packets */ 1828 E1000_RCTL_BAM | /* RX All Bcast Pkts */ 1829 E1000_RCTL_PMCF); /* RX All MAC Ctrl Pkts */ 1830 1831 rctl &= ~(E1000_RCTL_VFE | /* Disable VLAN filter */ 1832 E1000_RCTL_DPF | /* Allow filtered pause */ 1833 E1000_RCTL_CFIEN); /* Dis VLAN CFIEN Filter */ 1834 /* Do not mess with E1000_CTRL_VME, it affects transmit as well, 1835 * and that breaks VLANs. 1836 */ 1837 } 1838 1839 ew32(RCTL, rctl); 1840 } 1841 1842 /** 1843 * e1000_configure_rx - Configure 8254x Receive Unit after Reset 1844 * @adapter: board private structure 1845 * 1846 * Configure the Rx unit of the MAC after a reset. 1847 **/ 1848 static void e1000_configure_rx(struct e1000_adapter *adapter) 1849 { 1850 u64 rdba; 1851 struct e1000_hw *hw = &adapter->hw; 1852 u32 rdlen, rctl, rxcsum; 1853 1854 if (adapter->netdev->mtu > ETH_DATA_LEN) { 1855 rdlen = adapter->rx_ring[0].count * 1856 sizeof(struct e1000_rx_desc); 1857 adapter->clean_rx = e1000_clean_jumbo_rx_irq; 1858 adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers; 1859 } else { 1860 rdlen = adapter->rx_ring[0].count * 1861 sizeof(struct e1000_rx_desc); 1862 adapter->clean_rx = e1000_clean_rx_irq; 1863 adapter->alloc_rx_buf = e1000_alloc_rx_buffers; 1864 } 1865 1866 /* disable receives while setting up the descriptors */ 1867 rctl = er32(RCTL); 1868 ew32(RCTL, rctl & ~E1000_RCTL_EN); 1869 1870 /* set the Receive Delay Timer Register */ 1871 ew32(RDTR, adapter->rx_int_delay); 1872 1873 if (hw->mac_type >= e1000_82540) { 1874 ew32(RADV, adapter->rx_abs_int_delay); 1875 if (adapter->itr_setting != 0) 1876 ew32(ITR, 1000000000 / (adapter->itr * 256)); 1877 } 1878 1879 /* Setup the HW Rx Head and Tail Descriptor Pointers and 1880 * the Base and Length of the Rx Descriptor Ring 1881 */ 1882 switch (adapter->num_rx_queues) { 1883 case 1: 1884 default: 1885 rdba = adapter->rx_ring[0].dma; 1886 ew32(RDLEN, rdlen); 1887 ew32(RDBAH, (rdba >> 32)); 1888 ew32(RDBAL, (rdba & 0x00000000ffffffffULL)); 1889 ew32(RDT, 0); 1890 ew32(RDH, 0); 1891 adapter->rx_ring[0].rdh = ((hw->mac_type >= e1000_82543) ? 1892 E1000_RDH : E1000_82542_RDH); 1893 adapter->rx_ring[0].rdt = ((hw->mac_type >= e1000_82543) ? 1894 E1000_RDT : E1000_82542_RDT); 1895 break; 1896 } 1897 1898 /* Enable 82543 Receive Checksum Offload for TCP and UDP */ 1899 if (hw->mac_type >= e1000_82543) { 1900 rxcsum = er32(RXCSUM); 1901 if (adapter->rx_csum) 1902 rxcsum |= E1000_RXCSUM_TUOFL; 1903 else 1904 /* don't need to clear IPPCSE as it defaults to 0 */ 1905 rxcsum &= ~E1000_RXCSUM_TUOFL; 1906 ew32(RXCSUM, rxcsum); 1907 } 1908 1909 /* Enable Receives */ 1910 ew32(RCTL, rctl | E1000_RCTL_EN); 1911 } 1912 1913 /** 1914 * e1000_free_tx_resources - Free Tx Resources per Queue 1915 * @adapter: board private structure 1916 * @tx_ring: Tx descriptor ring for a specific queue 1917 * 1918 * Free all transmit software resources 1919 **/ 1920 static void e1000_free_tx_resources(struct e1000_adapter *adapter, 1921 struct e1000_tx_ring *tx_ring) 1922 { 1923 struct pci_dev *pdev = adapter->pdev; 1924 1925 e1000_clean_tx_ring(adapter, tx_ring); 1926 1927 vfree(tx_ring->buffer_info); 1928 tx_ring->buffer_info = NULL; 1929 1930 dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc, 1931 tx_ring->dma); 1932 1933 tx_ring->desc = NULL; 1934 } 1935 1936 /** 1937 * e1000_free_all_tx_resources - Free Tx Resources for All Queues 1938 * @adapter: board private structure 1939 * 1940 * Free all transmit software resources 1941 **/ 1942 void e1000_free_all_tx_resources(struct e1000_adapter *adapter) 1943 { 1944 int i; 1945 1946 for (i = 0; i < adapter->num_tx_queues; i++) 1947 e1000_free_tx_resources(adapter, &adapter->tx_ring[i]); 1948 } 1949 1950 static void e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter, 1951 struct e1000_buffer *buffer_info) 1952 { 1953 if (buffer_info->dma) { 1954 if (buffer_info->mapped_as_page) 1955 dma_unmap_page(&adapter->pdev->dev, buffer_info->dma, 1956 buffer_info->length, DMA_TO_DEVICE); 1957 else 1958 dma_unmap_single(&adapter->pdev->dev, buffer_info->dma, 1959 buffer_info->length, 1960 DMA_TO_DEVICE); 1961 buffer_info->dma = 0; 1962 } 1963 if (buffer_info->skb) { 1964 dev_kfree_skb_any(buffer_info->skb); 1965 buffer_info->skb = NULL; 1966 } 1967 buffer_info->time_stamp = 0; 1968 /* buffer_info must be completely set up in the transmit path */ 1969 } 1970 1971 /** 1972 * e1000_clean_tx_ring - Free Tx Buffers 1973 * @adapter: board private structure 1974 * @tx_ring: ring to be cleaned 1975 **/ 1976 static void e1000_clean_tx_ring(struct e1000_adapter *adapter, 1977 struct e1000_tx_ring *tx_ring) 1978 { 1979 struct e1000_hw *hw = &adapter->hw; 1980 struct e1000_buffer *buffer_info; 1981 unsigned long size; 1982 unsigned int i; 1983 1984 /* Free all the Tx ring sk_buffs */ 1985 1986 for (i = 0; i < tx_ring->count; i++) { 1987 buffer_info = &tx_ring->buffer_info[i]; 1988 e1000_unmap_and_free_tx_resource(adapter, buffer_info); 1989 } 1990 1991 netdev_reset_queue(adapter->netdev); 1992 size = sizeof(struct e1000_buffer) * tx_ring->count; 1993 memset(tx_ring->buffer_info, 0, size); 1994 1995 /* Zero out the descriptor ring */ 1996 1997 memset(tx_ring->desc, 0, tx_ring->size); 1998 1999 tx_ring->next_to_use = 0; 2000 tx_ring->next_to_clean = 0; 2001 tx_ring->last_tx_tso = false; 2002 2003 writel(0, hw->hw_addr + tx_ring->tdh); 2004 writel(0, hw->hw_addr + tx_ring->tdt); 2005 } 2006 2007 /** 2008 * e1000_clean_all_tx_rings - Free Tx Buffers for all queues 2009 * @adapter: board private structure 2010 **/ 2011 static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter) 2012 { 2013 int i; 2014 2015 for (i = 0; i < adapter->num_tx_queues; i++) 2016 e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]); 2017 } 2018 2019 /** 2020 * e1000_free_rx_resources - Free Rx Resources 2021 * @adapter: board private structure 2022 * @rx_ring: ring to clean the resources from 2023 * 2024 * Free all receive software resources 2025 **/ 2026 static void e1000_free_rx_resources(struct e1000_adapter *adapter, 2027 struct e1000_rx_ring *rx_ring) 2028 { 2029 struct pci_dev *pdev = adapter->pdev; 2030 2031 e1000_clean_rx_ring(adapter, rx_ring); 2032 2033 vfree(rx_ring->buffer_info); 2034 rx_ring->buffer_info = NULL; 2035 2036 dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc, 2037 rx_ring->dma); 2038 2039 rx_ring->desc = NULL; 2040 } 2041 2042 /** 2043 * e1000_free_all_rx_resources - Free Rx Resources for All Queues 2044 * @adapter: board private structure 2045 * 2046 * Free all receive software resources 2047 **/ 2048 void e1000_free_all_rx_resources(struct e1000_adapter *adapter) 2049 { 2050 int i; 2051 2052 for (i = 0; i < adapter->num_rx_queues; i++) 2053 e1000_free_rx_resources(adapter, &adapter->rx_ring[i]); 2054 } 2055 2056 /** 2057 * e1000_clean_rx_ring - Free Rx Buffers per Queue 2058 * @adapter: board private structure 2059 * @rx_ring: ring to free buffers from 2060 **/ 2061 static void e1000_clean_rx_ring(struct e1000_adapter *adapter, 2062 struct e1000_rx_ring *rx_ring) 2063 { 2064 struct e1000_hw *hw = &adapter->hw; 2065 struct e1000_buffer *buffer_info; 2066 struct pci_dev *pdev = adapter->pdev; 2067 unsigned long size; 2068 unsigned int i; 2069 2070 /* Free all the Rx ring sk_buffs */ 2071 for (i = 0; i < rx_ring->count; i++) { 2072 buffer_info = &rx_ring->buffer_info[i]; 2073 if (buffer_info->dma && 2074 adapter->clean_rx == e1000_clean_rx_irq) { 2075 dma_unmap_single(&pdev->dev, buffer_info->dma, 2076 buffer_info->length, 2077 DMA_FROM_DEVICE); 2078 } else if (buffer_info->dma && 2079 adapter->clean_rx == e1000_clean_jumbo_rx_irq) { 2080 dma_unmap_page(&pdev->dev, buffer_info->dma, 2081 buffer_info->length, 2082 DMA_FROM_DEVICE); 2083 } 2084 2085 buffer_info->dma = 0; 2086 if (buffer_info->page) { 2087 put_page(buffer_info->page); 2088 buffer_info->page = NULL; 2089 } 2090 if (buffer_info->skb) { 2091 dev_kfree_skb(buffer_info->skb); 2092 buffer_info->skb = NULL; 2093 } 2094 } 2095 2096 /* there also may be some cached data from a chained receive */ 2097 if (rx_ring->rx_skb_top) { 2098 dev_kfree_skb(rx_ring->rx_skb_top); 2099 rx_ring->rx_skb_top = NULL; 2100 } 2101 2102 size = sizeof(struct e1000_buffer) * rx_ring->count; 2103 memset(rx_ring->buffer_info, 0, size); 2104 2105 /* Zero out the descriptor ring */ 2106 memset(rx_ring->desc, 0, rx_ring->size); 2107 2108 rx_ring->next_to_clean = 0; 2109 rx_ring->next_to_use = 0; 2110 2111 writel(0, hw->hw_addr + rx_ring->rdh); 2112 writel(0, hw->hw_addr + rx_ring->rdt); 2113 } 2114 2115 /** 2116 * e1000_clean_all_rx_rings - Free Rx Buffers for all queues 2117 * @adapter: board private structure 2118 **/ 2119 static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter) 2120 { 2121 int i; 2122 2123 for (i = 0; i < adapter->num_rx_queues; i++) 2124 e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]); 2125 } 2126 2127 /* The 82542 2.0 (revision 2) needs to have the receive unit in reset 2128 * and memory write and invalidate disabled for certain operations 2129 */ 2130 static void e1000_enter_82542_rst(struct e1000_adapter *adapter) 2131 { 2132 struct e1000_hw *hw = &adapter->hw; 2133 struct net_device *netdev = adapter->netdev; 2134 u32 rctl; 2135 2136 e1000_pci_clear_mwi(hw); 2137 2138 rctl = er32(RCTL); 2139 rctl |= E1000_RCTL_RST; 2140 ew32(RCTL, rctl); 2141 E1000_WRITE_FLUSH(); 2142 mdelay(5); 2143 2144 if (netif_running(netdev)) 2145 e1000_clean_all_rx_rings(adapter); 2146 } 2147 2148 static void e1000_leave_82542_rst(struct e1000_adapter *adapter) 2149 { 2150 struct e1000_hw *hw = &adapter->hw; 2151 struct net_device *netdev = adapter->netdev; 2152 u32 rctl; 2153 2154 rctl = er32(RCTL); 2155 rctl &= ~E1000_RCTL_RST; 2156 ew32(RCTL, rctl); 2157 E1000_WRITE_FLUSH(); 2158 mdelay(5); 2159 2160 if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE) 2161 e1000_pci_set_mwi(hw); 2162 2163 if (netif_running(netdev)) { 2164 /* No need to loop, because 82542 supports only 1 queue */ 2165 struct e1000_rx_ring *ring = &adapter->rx_ring[0]; 2166 e1000_configure_rx(adapter); 2167 adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring)); 2168 } 2169 } 2170 2171 /** 2172 * e1000_set_mac - Change the Ethernet Address of the NIC 2173 * @netdev: network interface device structure 2174 * @p: pointer to an address structure 2175 * 2176 * Returns 0 on success, negative on failure 2177 **/ 2178 static int e1000_set_mac(struct net_device *netdev, void *p) 2179 { 2180 struct e1000_adapter *adapter = netdev_priv(netdev); 2181 struct e1000_hw *hw = &adapter->hw; 2182 struct sockaddr *addr = p; 2183 2184 if (!is_valid_ether_addr(addr->sa_data)) 2185 return -EADDRNOTAVAIL; 2186 2187 /* 82542 2.0 needs to be in reset to write receive address registers */ 2188 2189 if (hw->mac_type == e1000_82542_rev2_0) 2190 e1000_enter_82542_rst(adapter); 2191 2192 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len); 2193 memcpy(hw->mac_addr, addr->sa_data, netdev->addr_len); 2194 2195 e1000_rar_set(hw, hw->mac_addr, 0); 2196 2197 if (hw->mac_type == e1000_82542_rev2_0) 2198 e1000_leave_82542_rst(adapter); 2199 2200 return 0; 2201 } 2202 2203 /** 2204 * e1000_set_rx_mode - Secondary Unicast, Multicast and Promiscuous mode set 2205 * @netdev: network interface device structure 2206 * 2207 * The set_rx_mode entry point is called whenever the unicast or multicast 2208 * address lists or the network interface flags are updated. This routine is 2209 * responsible for configuring the hardware for proper unicast, multicast, 2210 * promiscuous mode, and all-multi behavior. 2211 **/ 2212 static void e1000_set_rx_mode(struct net_device *netdev) 2213 { 2214 struct e1000_adapter *adapter = netdev_priv(netdev); 2215 struct e1000_hw *hw = &adapter->hw; 2216 struct netdev_hw_addr *ha; 2217 bool use_uc = false; 2218 u32 rctl; 2219 u32 hash_value; 2220 int i, rar_entries = E1000_RAR_ENTRIES; 2221 int mta_reg_count = E1000_NUM_MTA_REGISTERS; 2222 u32 *mcarray = kcalloc(mta_reg_count, sizeof(u32), GFP_ATOMIC); 2223 2224 if (!mcarray) 2225 return; 2226 2227 /* Check for Promiscuous and All Multicast modes */ 2228 2229 rctl = er32(RCTL); 2230 2231 if (netdev->flags & IFF_PROMISC) { 2232 rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE); 2233 rctl &= ~E1000_RCTL_VFE; 2234 } else { 2235 if (netdev->flags & IFF_ALLMULTI) 2236 rctl |= E1000_RCTL_MPE; 2237 else 2238 rctl &= ~E1000_RCTL_MPE; 2239 /* Enable VLAN filter if there is a VLAN */ 2240 if (e1000_vlan_used(adapter)) 2241 rctl |= E1000_RCTL_VFE; 2242 } 2243 2244 if (netdev_uc_count(netdev) > rar_entries - 1) { 2245 rctl |= E1000_RCTL_UPE; 2246 } else if (!(netdev->flags & IFF_PROMISC)) { 2247 rctl &= ~E1000_RCTL_UPE; 2248 use_uc = true; 2249 } 2250 2251 ew32(RCTL, rctl); 2252 2253 /* 82542 2.0 needs to be in reset to write receive address registers */ 2254 2255 if (hw->mac_type == e1000_82542_rev2_0) 2256 e1000_enter_82542_rst(adapter); 2257 2258 /* load the first 14 addresses into the exact filters 1-14. Unicast 2259 * addresses take precedence to avoid disabling unicast filtering 2260 * when possible. 2261 * 2262 * RAR 0 is used for the station MAC address 2263 * if there are not 14 addresses, go ahead and clear the filters 2264 */ 2265 i = 1; 2266 if (use_uc) 2267 netdev_for_each_uc_addr(ha, netdev) { 2268 if (i == rar_entries) 2269 break; 2270 e1000_rar_set(hw, ha->addr, i++); 2271 } 2272 2273 netdev_for_each_mc_addr(ha, netdev) { 2274 if (i == rar_entries) { 2275 /* load any remaining addresses into the hash table */ 2276 u32 hash_reg, hash_bit, mta; 2277 hash_value = e1000_hash_mc_addr(hw, ha->addr); 2278 hash_reg = (hash_value >> 5) & 0x7F; 2279 hash_bit = hash_value & 0x1F; 2280 mta = (1 << hash_bit); 2281 mcarray[hash_reg] |= mta; 2282 } else { 2283 e1000_rar_set(hw, ha->addr, i++); 2284 } 2285 } 2286 2287 for (; i < rar_entries; i++) { 2288 E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0); 2289 E1000_WRITE_FLUSH(); 2290 E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0); 2291 E1000_WRITE_FLUSH(); 2292 } 2293 2294 /* write the hash table completely, write from bottom to avoid 2295 * both stupid write combining chipsets, and flushing each write 2296 */ 2297 for (i = mta_reg_count - 1; i >= 0 ; i--) { 2298 /* If we are on an 82544 has an errata where writing odd 2299 * offsets overwrites the previous even offset, but writing 2300 * backwards over the range solves the issue by always 2301 * writing the odd offset first 2302 */ 2303 E1000_WRITE_REG_ARRAY(hw, MTA, i, mcarray[i]); 2304 } 2305 E1000_WRITE_FLUSH(); 2306 2307 if (hw->mac_type == e1000_82542_rev2_0) 2308 e1000_leave_82542_rst(adapter); 2309 2310 kfree(mcarray); 2311 } 2312 2313 /** 2314 * e1000_update_phy_info_task - get phy info 2315 * @work: work struct contained inside adapter struct 2316 * 2317 * Need to wait a few seconds after link up to get diagnostic information from 2318 * the phy 2319 */ 2320 static void e1000_update_phy_info_task(struct work_struct *work) 2321 { 2322 struct e1000_adapter *adapter = container_of(work, 2323 struct e1000_adapter, 2324 phy_info_task.work); 2325 2326 e1000_phy_get_info(&adapter->hw, &adapter->phy_info); 2327 } 2328 2329 /** 2330 * e1000_82547_tx_fifo_stall_task - task to complete work 2331 * @work: work struct contained inside adapter struct 2332 **/ 2333 static void e1000_82547_tx_fifo_stall_task(struct work_struct *work) 2334 { 2335 struct e1000_adapter *adapter = container_of(work, 2336 struct e1000_adapter, 2337 fifo_stall_task.work); 2338 struct e1000_hw *hw = &adapter->hw; 2339 struct net_device *netdev = adapter->netdev; 2340 u32 tctl; 2341 2342 if (atomic_read(&adapter->tx_fifo_stall)) { 2343 if ((er32(TDT) == er32(TDH)) && 2344 (er32(TDFT) == er32(TDFH)) && 2345 (er32(TDFTS) == er32(TDFHS))) { 2346 tctl = er32(TCTL); 2347 ew32(TCTL, tctl & ~E1000_TCTL_EN); 2348 ew32(TDFT, adapter->tx_head_addr); 2349 ew32(TDFH, adapter->tx_head_addr); 2350 ew32(TDFTS, adapter->tx_head_addr); 2351 ew32(TDFHS, adapter->tx_head_addr); 2352 ew32(TCTL, tctl); 2353 E1000_WRITE_FLUSH(); 2354 2355 adapter->tx_fifo_head = 0; 2356 atomic_set(&adapter->tx_fifo_stall, 0); 2357 netif_wake_queue(netdev); 2358 } else if (!test_bit(__E1000_DOWN, &adapter->flags)) { 2359 schedule_delayed_work(&adapter->fifo_stall_task, 1); 2360 } 2361 } 2362 } 2363 2364 bool e1000_has_link(struct e1000_adapter *adapter) 2365 { 2366 struct e1000_hw *hw = &adapter->hw; 2367 bool link_active = false; 2368 2369 /* get_link_status is set on LSC (link status) interrupt or rx 2370 * sequence error interrupt (except on intel ce4100). 2371 * get_link_status will stay false until the 2372 * e1000_check_for_link establishes link for copper adapters 2373 * ONLY 2374 */ 2375 switch (hw->media_type) { 2376 case e1000_media_type_copper: 2377 if (hw->mac_type == e1000_ce4100) 2378 hw->get_link_status = 1; 2379 if (hw->get_link_status) { 2380 e1000_check_for_link(hw); 2381 link_active = !hw->get_link_status; 2382 } else { 2383 link_active = true; 2384 } 2385 break; 2386 case e1000_media_type_fiber: 2387 e1000_check_for_link(hw); 2388 link_active = !!(er32(STATUS) & E1000_STATUS_LU); 2389 break; 2390 case e1000_media_type_internal_serdes: 2391 e1000_check_for_link(hw); 2392 link_active = hw->serdes_has_link; 2393 break; 2394 default: 2395 break; 2396 } 2397 2398 return link_active; 2399 } 2400 2401 /** 2402 * e1000_watchdog - work function 2403 * @work: work struct contained inside adapter struct 2404 **/ 2405 static void e1000_watchdog(struct work_struct *work) 2406 { 2407 struct e1000_adapter *adapter = container_of(work, 2408 struct e1000_adapter, 2409 watchdog_task.work); 2410 struct e1000_hw *hw = &adapter->hw; 2411 struct net_device *netdev = adapter->netdev; 2412 struct e1000_tx_ring *txdr = adapter->tx_ring; 2413 u32 link, tctl; 2414 2415 link = e1000_has_link(adapter); 2416 if ((netif_carrier_ok(netdev)) && link) 2417 goto link_up; 2418 2419 if (link) { 2420 if (!netif_carrier_ok(netdev)) { 2421 u32 ctrl; 2422 bool txb2b = true; 2423 /* update snapshot of PHY registers on LSC */ 2424 e1000_get_speed_and_duplex(hw, 2425 &adapter->link_speed, 2426 &adapter->link_duplex); 2427 2428 ctrl = er32(CTRL); 2429 pr_info("%s NIC Link is Up %d Mbps %s, " 2430 "Flow Control: %s\n", 2431 netdev->name, 2432 adapter->link_speed, 2433 adapter->link_duplex == FULL_DUPLEX ? 2434 "Full Duplex" : "Half Duplex", 2435 ((ctrl & E1000_CTRL_TFCE) && (ctrl & 2436 E1000_CTRL_RFCE)) ? "RX/TX" : ((ctrl & 2437 E1000_CTRL_RFCE) ? "RX" : ((ctrl & 2438 E1000_CTRL_TFCE) ? "TX" : "None"))); 2439 2440 /* adjust timeout factor according to speed/duplex */ 2441 adapter->tx_timeout_factor = 1; 2442 switch (adapter->link_speed) { 2443 case SPEED_10: 2444 txb2b = false; 2445 adapter->tx_timeout_factor = 16; 2446 break; 2447 case SPEED_100: 2448 txb2b = false; 2449 /* maybe add some timeout factor ? */ 2450 break; 2451 } 2452 2453 /* enable transmits in the hardware */ 2454 tctl = er32(TCTL); 2455 tctl |= E1000_TCTL_EN; 2456 ew32(TCTL, tctl); 2457 2458 netif_carrier_on(netdev); 2459 if (!test_bit(__E1000_DOWN, &adapter->flags)) 2460 schedule_delayed_work(&adapter->phy_info_task, 2461 2 * HZ); 2462 adapter->smartspeed = 0; 2463 } 2464 } else { 2465 if (netif_carrier_ok(netdev)) { 2466 adapter->link_speed = 0; 2467 adapter->link_duplex = 0; 2468 pr_info("%s NIC Link is Down\n", 2469 netdev->name); 2470 netif_carrier_off(netdev); 2471 2472 if (!test_bit(__E1000_DOWN, &adapter->flags)) 2473 schedule_delayed_work(&adapter->phy_info_task, 2474 2 * HZ); 2475 } 2476 2477 e1000_smartspeed(adapter); 2478 } 2479 2480 link_up: 2481 e1000_update_stats(adapter); 2482 2483 hw->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old; 2484 adapter->tpt_old = adapter->stats.tpt; 2485 hw->collision_delta = adapter->stats.colc - adapter->colc_old; 2486 adapter->colc_old = adapter->stats.colc; 2487 2488 adapter->gorcl = adapter->stats.gorcl - adapter->gorcl_old; 2489 adapter->gorcl_old = adapter->stats.gorcl; 2490 adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old; 2491 adapter->gotcl_old = adapter->stats.gotcl; 2492 2493 e1000_update_adaptive(hw); 2494 2495 if (!netif_carrier_ok(netdev)) { 2496 if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) { 2497 /* We've lost link, so the controller stops DMA, 2498 * but we've got queued Tx work that's never going 2499 * to get done, so reset controller to flush Tx. 2500 * (Do the reset outside of interrupt context). 2501 */ 2502 adapter->tx_timeout_count++; 2503 schedule_work(&adapter->reset_task); 2504 /* exit immediately since reset is imminent */ 2505 return; 2506 } 2507 } 2508 2509 /* Simple mode for Interrupt Throttle Rate (ITR) */ 2510 if (hw->mac_type >= e1000_82540 && adapter->itr_setting == 4) { 2511 /* Symmetric Tx/Rx gets a reduced ITR=2000; 2512 * Total asymmetrical Tx or Rx gets ITR=8000; 2513 * everyone else is between 2000-8000. 2514 */ 2515 u32 goc = (adapter->gotcl + adapter->gorcl) / 10000; 2516 u32 dif = (adapter->gotcl > adapter->gorcl ? 2517 adapter->gotcl - adapter->gorcl : 2518 adapter->gorcl - adapter->gotcl) / 10000; 2519 u32 itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000; 2520 2521 ew32(ITR, 1000000000 / (itr * 256)); 2522 } 2523 2524 /* Cause software interrupt to ensure rx ring is cleaned */ 2525 ew32(ICS, E1000_ICS_RXDMT0); 2526 2527 /* Force detection of hung controller every watchdog period */ 2528 adapter->detect_tx_hung = true; 2529 2530 /* Reschedule the task */ 2531 if (!test_bit(__E1000_DOWN, &adapter->flags)) 2532 schedule_delayed_work(&adapter->watchdog_task, 2 * HZ); 2533 } 2534 2535 enum latency_range { 2536 lowest_latency = 0, 2537 low_latency = 1, 2538 bulk_latency = 2, 2539 latency_invalid = 255 2540 }; 2541 2542 /** 2543 * e1000_update_itr - update the dynamic ITR value based on statistics 2544 * @adapter: pointer to adapter 2545 * @itr_setting: current adapter->itr 2546 * @packets: the number of packets during this measurement interval 2547 * @bytes: the number of bytes during this measurement interval 2548 * 2549 * Stores a new ITR value based on packets and byte 2550 * counts during the last interrupt. The advantage of per interrupt 2551 * computation is faster updates and more accurate ITR for the current 2552 * traffic pattern. Constants in this function were computed 2553 * based on theoretical maximum wire speed and thresholds were set based 2554 * on testing data as well as attempting to minimize response time 2555 * while increasing bulk throughput. 2556 * this functionality is controlled by the InterruptThrottleRate module 2557 * parameter (see e1000_param.c) 2558 **/ 2559 static unsigned int e1000_update_itr(struct e1000_adapter *adapter, 2560 u16 itr_setting, int packets, int bytes) 2561 { 2562 unsigned int retval = itr_setting; 2563 struct e1000_hw *hw = &adapter->hw; 2564 2565 if (unlikely(hw->mac_type < e1000_82540)) 2566 goto update_itr_done; 2567 2568 if (packets == 0) 2569 goto update_itr_done; 2570 2571 switch (itr_setting) { 2572 case lowest_latency: 2573 /* jumbo frames get bulk treatment*/ 2574 if (bytes/packets > 8000) 2575 retval = bulk_latency; 2576 else if ((packets < 5) && (bytes > 512)) 2577 retval = low_latency; 2578 break; 2579 case low_latency: /* 50 usec aka 20000 ints/s */ 2580 if (bytes > 10000) { 2581 /* jumbo frames need bulk latency setting */ 2582 if (bytes/packets > 8000) 2583 retval = bulk_latency; 2584 else if ((packets < 10) || ((bytes/packets) > 1200)) 2585 retval = bulk_latency; 2586 else if ((packets > 35)) 2587 retval = lowest_latency; 2588 } else if (bytes/packets > 2000) 2589 retval = bulk_latency; 2590 else if (packets <= 2 && bytes < 512) 2591 retval = lowest_latency; 2592 break; 2593 case bulk_latency: /* 250 usec aka 4000 ints/s */ 2594 if (bytes > 25000) { 2595 if (packets > 35) 2596 retval = low_latency; 2597 } else if (bytes < 6000) { 2598 retval = low_latency; 2599 } 2600 break; 2601 } 2602 2603 update_itr_done: 2604 return retval; 2605 } 2606 2607 static void e1000_set_itr(struct e1000_adapter *adapter) 2608 { 2609 struct e1000_hw *hw = &adapter->hw; 2610 u16 current_itr; 2611 u32 new_itr = adapter->itr; 2612 2613 if (unlikely(hw->mac_type < e1000_82540)) 2614 return; 2615 2616 /* for non-gigabit speeds, just fix the interrupt rate at 4000 */ 2617 if (unlikely(adapter->link_speed != SPEED_1000)) { 2618 current_itr = 0; 2619 new_itr = 4000; 2620 goto set_itr_now; 2621 } 2622 2623 adapter->tx_itr = e1000_update_itr(adapter, adapter->tx_itr, 2624 adapter->total_tx_packets, 2625 adapter->total_tx_bytes); 2626 /* conservative mode (itr 3) eliminates the lowest_latency setting */ 2627 if (adapter->itr_setting == 3 && adapter->tx_itr == lowest_latency) 2628 adapter->tx_itr = low_latency; 2629 2630 adapter->rx_itr = e1000_update_itr(adapter, adapter->rx_itr, 2631 adapter->total_rx_packets, 2632 adapter->total_rx_bytes); 2633 /* conservative mode (itr 3) eliminates the lowest_latency setting */ 2634 if (adapter->itr_setting == 3 && adapter->rx_itr == lowest_latency) 2635 adapter->rx_itr = low_latency; 2636 2637 current_itr = max(adapter->rx_itr, adapter->tx_itr); 2638 2639 switch (current_itr) { 2640 /* counts and packets in update_itr are dependent on these numbers */ 2641 case lowest_latency: 2642 new_itr = 70000; 2643 break; 2644 case low_latency: 2645 new_itr = 20000; /* aka hwitr = ~200 */ 2646 break; 2647 case bulk_latency: 2648 new_itr = 4000; 2649 break; 2650 default: 2651 break; 2652 } 2653 2654 set_itr_now: 2655 if (new_itr != adapter->itr) { 2656 /* this attempts to bias the interrupt rate towards Bulk 2657 * by adding intermediate steps when interrupt rate is 2658 * increasing 2659 */ 2660 new_itr = new_itr > adapter->itr ? 2661 min(adapter->itr + (new_itr >> 2), new_itr) : 2662 new_itr; 2663 adapter->itr = new_itr; 2664 ew32(ITR, 1000000000 / (new_itr * 256)); 2665 } 2666 } 2667 2668 #define E1000_TX_FLAGS_CSUM 0x00000001 2669 #define E1000_TX_FLAGS_VLAN 0x00000002 2670 #define E1000_TX_FLAGS_TSO 0x00000004 2671 #define E1000_TX_FLAGS_IPV4 0x00000008 2672 #define E1000_TX_FLAGS_NO_FCS 0x00000010 2673 #define E1000_TX_FLAGS_VLAN_MASK 0xffff0000 2674 #define E1000_TX_FLAGS_VLAN_SHIFT 16 2675 2676 static int e1000_tso(struct e1000_adapter *adapter, 2677 struct e1000_tx_ring *tx_ring, struct sk_buff *skb) 2678 { 2679 struct e1000_context_desc *context_desc; 2680 struct e1000_buffer *buffer_info; 2681 unsigned int i; 2682 u32 cmd_length = 0; 2683 u16 ipcse = 0, tucse, mss; 2684 u8 ipcss, ipcso, tucss, tucso, hdr_len; 2685 int err; 2686 2687 if (skb_is_gso(skb)) { 2688 if (skb_header_cloned(skb)) { 2689 err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC); 2690 if (err) 2691 return err; 2692 } 2693 2694 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb); 2695 mss = skb_shinfo(skb)->gso_size; 2696 if (skb->protocol == htons(ETH_P_IP)) { 2697 struct iphdr *iph = ip_hdr(skb); 2698 iph->tot_len = 0; 2699 iph->check = 0; 2700 tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr, 2701 iph->daddr, 0, 2702 IPPROTO_TCP, 2703 0); 2704 cmd_length = E1000_TXD_CMD_IP; 2705 ipcse = skb_transport_offset(skb) - 1; 2706 } else if (skb->protocol == htons(ETH_P_IPV6)) { 2707 ipv6_hdr(skb)->payload_len = 0; 2708 tcp_hdr(skb)->check = 2709 ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr, 2710 &ipv6_hdr(skb)->daddr, 2711 0, IPPROTO_TCP, 0); 2712 ipcse = 0; 2713 } 2714 ipcss = skb_network_offset(skb); 2715 ipcso = (void *)&(ip_hdr(skb)->check) - (void *)skb->data; 2716 tucss = skb_transport_offset(skb); 2717 tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data; 2718 tucse = 0; 2719 2720 cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE | 2721 E1000_TXD_CMD_TCP | (skb->len - (hdr_len))); 2722 2723 i = tx_ring->next_to_use; 2724 context_desc = E1000_CONTEXT_DESC(*tx_ring, i); 2725 buffer_info = &tx_ring->buffer_info[i]; 2726 2727 context_desc->lower_setup.ip_fields.ipcss = ipcss; 2728 context_desc->lower_setup.ip_fields.ipcso = ipcso; 2729 context_desc->lower_setup.ip_fields.ipcse = cpu_to_le16(ipcse); 2730 context_desc->upper_setup.tcp_fields.tucss = tucss; 2731 context_desc->upper_setup.tcp_fields.tucso = tucso; 2732 context_desc->upper_setup.tcp_fields.tucse = cpu_to_le16(tucse); 2733 context_desc->tcp_seg_setup.fields.mss = cpu_to_le16(mss); 2734 context_desc->tcp_seg_setup.fields.hdr_len = hdr_len; 2735 context_desc->cmd_and_length = cpu_to_le32(cmd_length); 2736 2737 buffer_info->time_stamp = jiffies; 2738 buffer_info->next_to_watch = i; 2739 2740 if (++i == tx_ring->count) i = 0; 2741 tx_ring->next_to_use = i; 2742 2743 return true; 2744 } 2745 return false; 2746 } 2747 2748 static bool e1000_tx_csum(struct e1000_adapter *adapter, 2749 struct e1000_tx_ring *tx_ring, struct sk_buff *skb) 2750 { 2751 struct e1000_context_desc *context_desc; 2752 struct e1000_buffer *buffer_info; 2753 unsigned int i; 2754 u8 css; 2755 u32 cmd_len = E1000_TXD_CMD_DEXT; 2756 2757 if (skb->ip_summed != CHECKSUM_PARTIAL) 2758 return false; 2759 2760 switch (skb->protocol) { 2761 case cpu_to_be16(ETH_P_IP): 2762 if (ip_hdr(skb)->protocol == IPPROTO_TCP) 2763 cmd_len |= E1000_TXD_CMD_TCP; 2764 break; 2765 case cpu_to_be16(ETH_P_IPV6): 2766 /* XXX not handling all IPV6 headers */ 2767 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP) 2768 cmd_len |= E1000_TXD_CMD_TCP; 2769 break; 2770 default: 2771 if (unlikely(net_ratelimit())) 2772 e_warn(drv, "checksum_partial proto=%x!\n", 2773 skb->protocol); 2774 break; 2775 } 2776 2777 css = skb_checksum_start_offset(skb); 2778 2779 i = tx_ring->next_to_use; 2780 buffer_info = &tx_ring->buffer_info[i]; 2781 context_desc = E1000_CONTEXT_DESC(*tx_ring, i); 2782 2783 context_desc->lower_setup.ip_config = 0; 2784 context_desc->upper_setup.tcp_fields.tucss = css; 2785 context_desc->upper_setup.tcp_fields.tucso = 2786 css + skb->csum_offset; 2787 context_desc->upper_setup.tcp_fields.tucse = 0; 2788 context_desc->tcp_seg_setup.data = 0; 2789 context_desc->cmd_and_length = cpu_to_le32(cmd_len); 2790 2791 buffer_info->time_stamp = jiffies; 2792 buffer_info->next_to_watch = i; 2793 2794 if (unlikely(++i == tx_ring->count)) i = 0; 2795 tx_ring->next_to_use = i; 2796 2797 return true; 2798 } 2799 2800 #define E1000_MAX_TXD_PWR 12 2801 #define E1000_MAX_DATA_PER_TXD (1<<E1000_MAX_TXD_PWR) 2802 2803 static int e1000_tx_map(struct e1000_adapter *adapter, 2804 struct e1000_tx_ring *tx_ring, 2805 struct sk_buff *skb, unsigned int first, 2806 unsigned int max_per_txd, unsigned int nr_frags, 2807 unsigned int mss) 2808 { 2809 struct e1000_hw *hw = &adapter->hw; 2810 struct pci_dev *pdev = adapter->pdev; 2811 struct e1000_buffer *buffer_info; 2812 unsigned int len = skb_headlen(skb); 2813 unsigned int offset = 0, size, count = 0, i; 2814 unsigned int f, bytecount, segs; 2815 2816 i = tx_ring->next_to_use; 2817 2818 while (len) { 2819 buffer_info = &tx_ring->buffer_info[i]; 2820 size = min(len, max_per_txd); 2821 /* Workaround for Controller erratum -- 2822 * descriptor for non-tso packet in a linear SKB that follows a 2823 * tso gets written back prematurely before the data is fully 2824 * DMA'd to the controller 2825 */ 2826 if (!skb->data_len && tx_ring->last_tx_tso && 2827 !skb_is_gso(skb)) { 2828 tx_ring->last_tx_tso = false; 2829 size -= 4; 2830 } 2831 2832 /* Workaround for premature desc write-backs 2833 * in TSO mode. Append 4-byte sentinel desc 2834 */ 2835 if (unlikely(mss && !nr_frags && size == len && size > 8)) 2836 size -= 4; 2837 /* work-around for errata 10 and it applies 2838 * to all controllers in PCI-X mode 2839 * The fix is to make sure that the first descriptor of a 2840 * packet is smaller than 2048 - 16 - 16 (or 2016) bytes 2841 */ 2842 if (unlikely((hw->bus_type == e1000_bus_type_pcix) && 2843 (size > 2015) && count == 0)) 2844 size = 2015; 2845 2846 /* Workaround for potential 82544 hang in PCI-X. Avoid 2847 * terminating buffers within evenly-aligned dwords. 2848 */ 2849 if (unlikely(adapter->pcix_82544 && 2850 !((unsigned long)(skb->data + offset + size - 1) & 4) && 2851 size > 4)) 2852 size -= 4; 2853 2854 buffer_info->length = size; 2855 /* set time_stamp *before* dma to help avoid a possible race */ 2856 buffer_info->time_stamp = jiffies; 2857 buffer_info->mapped_as_page = false; 2858 buffer_info->dma = dma_map_single(&pdev->dev, 2859 skb->data + offset, 2860 size, DMA_TO_DEVICE); 2861 if (dma_mapping_error(&pdev->dev, buffer_info->dma)) 2862 goto dma_error; 2863 buffer_info->next_to_watch = i; 2864 2865 len -= size; 2866 offset += size; 2867 count++; 2868 if (len) { 2869 i++; 2870 if (unlikely(i == tx_ring->count)) 2871 i = 0; 2872 } 2873 } 2874 2875 for (f = 0; f < nr_frags; f++) { 2876 const struct skb_frag_struct *frag; 2877 2878 frag = &skb_shinfo(skb)->frags[f]; 2879 len = skb_frag_size(frag); 2880 offset = 0; 2881 2882 while (len) { 2883 unsigned long bufend; 2884 i++; 2885 if (unlikely(i == tx_ring->count)) 2886 i = 0; 2887 2888 buffer_info = &tx_ring->buffer_info[i]; 2889 size = min(len, max_per_txd); 2890 /* Workaround for premature desc write-backs 2891 * in TSO mode. Append 4-byte sentinel desc 2892 */ 2893 if (unlikely(mss && f == (nr_frags-1) && 2894 size == len && size > 8)) 2895 size -= 4; 2896 /* Workaround for potential 82544 hang in PCI-X. 2897 * Avoid terminating buffers within evenly-aligned 2898 * dwords. 2899 */ 2900 bufend = (unsigned long) 2901 page_to_phys(skb_frag_page(frag)); 2902 bufend += offset + size - 1; 2903 if (unlikely(adapter->pcix_82544 && 2904 !(bufend & 4) && 2905 size > 4)) 2906 size -= 4; 2907 2908 buffer_info->length = size; 2909 buffer_info->time_stamp = jiffies; 2910 buffer_info->mapped_as_page = true; 2911 buffer_info->dma = skb_frag_dma_map(&pdev->dev, frag, 2912 offset, size, DMA_TO_DEVICE); 2913 if (dma_mapping_error(&pdev->dev, buffer_info->dma)) 2914 goto dma_error; 2915 buffer_info->next_to_watch = i; 2916 2917 len -= size; 2918 offset += size; 2919 count++; 2920 } 2921 } 2922 2923 segs = skb_shinfo(skb)->gso_segs ?: 1; 2924 /* multiply data chunks by size of headers */ 2925 bytecount = ((segs - 1) * skb_headlen(skb)) + skb->len; 2926 2927 tx_ring->buffer_info[i].skb = skb; 2928 tx_ring->buffer_info[i].segs = segs; 2929 tx_ring->buffer_info[i].bytecount = bytecount; 2930 tx_ring->buffer_info[first].next_to_watch = i; 2931 2932 return count; 2933 2934 dma_error: 2935 dev_err(&pdev->dev, "TX DMA map failed\n"); 2936 buffer_info->dma = 0; 2937 if (count) 2938 count--; 2939 2940 while (count--) { 2941 if (i==0) 2942 i += tx_ring->count; 2943 i--; 2944 buffer_info = &tx_ring->buffer_info[i]; 2945 e1000_unmap_and_free_tx_resource(adapter, buffer_info); 2946 } 2947 2948 return 0; 2949 } 2950 2951 static void e1000_tx_queue(struct e1000_adapter *adapter, 2952 struct e1000_tx_ring *tx_ring, int tx_flags, 2953 int count) 2954 { 2955 struct e1000_hw *hw = &adapter->hw; 2956 struct e1000_tx_desc *tx_desc = NULL; 2957 struct e1000_buffer *buffer_info; 2958 u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS; 2959 unsigned int i; 2960 2961 if (likely(tx_flags & E1000_TX_FLAGS_TSO)) { 2962 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D | 2963 E1000_TXD_CMD_TSE; 2964 txd_upper |= E1000_TXD_POPTS_TXSM << 8; 2965 2966 if (likely(tx_flags & E1000_TX_FLAGS_IPV4)) 2967 txd_upper |= E1000_TXD_POPTS_IXSM << 8; 2968 } 2969 2970 if (likely(tx_flags & E1000_TX_FLAGS_CSUM)) { 2971 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 2972 txd_upper |= E1000_TXD_POPTS_TXSM << 8; 2973 } 2974 2975 if (unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) { 2976 txd_lower |= E1000_TXD_CMD_VLE; 2977 txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK); 2978 } 2979 2980 if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS)) 2981 txd_lower &= ~(E1000_TXD_CMD_IFCS); 2982 2983 i = tx_ring->next_to_use; 2984 2985 while (count--) { 2986 buffer_info = &tx_ring->buffer_info[i]; 2987 tx_desc = E1000_TX_DESC(*tx_ring, i); 2988 tx_desc->buffer_addr = cpu_to_le64(buffer_info->dma); 2989 tx_desc->lower.data = 2990 cpu_to_le32(txd_lower | buffer_info->length); 2991 tx_desc->upper.data = cpu_to_le32(txd_upper); 2992 if (unlikely(++i == tx_ring->count)) i = 0; 2993 } 2994 2995 tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd); 2996 2997 /* txd_cmd re-enables FCS, so we'll re-disable it here as desired. */ 2998 if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS)) 2999 tx_desc->lower.data &= ~(cpu_to_le32(E1000_TXD_CMD_IFCS)); 3000 3001 /* Force memory writes to complete before letting h/w 3002 * know there are new descriptors to fetch. (Only 3003 * applicable for weak-ordered memory model archs, 3004 * such as IA-64). 3005 */ 3006 wmb(); 3007 3008 tx_ring->next_to_use = i; 3009 writel(i, hw->hw_addr + tx_ring->tdt); 3010 /* we need this if more than one processor can write to our tail 3011 * at a time, it synchronizes IO on IA64/Altix systems 3012 */ 3013 mmiowb(); 3014 } 3015 3016 /* 82547 workaround to avoid controller hang in half-duplex environment. 3017 * The workaround is to avoid queuing a large packet that would span 3018 * the internal Tx FIFO ring boundary by notifying the stack to resend 3019 * the packet at a later time. This gives the Tx FIFO an opportunity to 3020 * flush all packets. When that occurs, we reset the Tx FIFO pointers 3021 * to the beginning of the Tx FIFO. 3022 */ 3023 3024 #define E1000_FIFO_HDR 0x10 3025 #define E1000_82547_PAD_LEN 0x3E0 3026 3027 static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter, 3028 struct sk_buff *skb) 3029 { 3030 u32 fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head; 3031 u32 skb_fifo_len = skb->len + E1000_FIFO_HDR; 3032 3033 skb_fifo_len = ALIGN(skb_fifo_len, E1000_FIFO_HDR); 3034 3035 if (adapter->link_duplex != HALF_DUPLEX) 3036 goto no_fifo_stall_required; 3037 3038 if (atomic_read(&adapter->tx_fifo_stall)) 3039 return 1; 3040 3041 if (skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) { 3042 atomic_set(&adapter->tx_fifo_stall, 1); 3043 return 1; 3044 } 3045 3046 no_fifo_stall_required: 3047 adapter->tx_fifo_head += skb_fifo_len; 3048 if (adapter->tx_fifo_head >= adapter->tx_fifo_size) 3049 adapter->tx_fifo_head -= adapter->tx_fifo_size; 3050 return 0; 3051 } 3052 3053 static int __e1000_maybe_stop_tx(struct net_device *netdev, int size) 3054 { 3055 struct e1000_adapter *adapter = netdev_priv(netdev); 3056 struct e1000_tx_ring *tx_ring = adapter->tx_ring; 3057 3058 netif_stop_queue(netdev); 3059 /* Herbert's original patch had: 3060 * smp_mb__after_netif_stop_queue(); 3061 * but since that doesn't exist yet, just open code it. 3062 */ 3063 smp_mb(); 3064 3065 /* We need to check again in a case another CPU has just 3066 * made room available. 3067 */ 3068 if (likely(E1000_DESC_UNUSED(tx_ring) < size)) 3069 return -EBUSY; 3070 3071 /* A reprieve! */ 3072 netif_start_queue(netdev); 3073 ++adapter->restart_queue; 3074 return 0; 3075 } 3076 3077 static int e1000_maybe_stop_tx(struct net_device *netdev, 3078 struct e1000_tx_ring *tx_ring, int size) 3079 { 3080 if (likely(E1000_DESC_UNUSED(tx_ring) >= size)) 3081 return 0; 3082 return __e1000_maybe_stop_tx(netdev, size); 3083 } 3084 3085 #define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 ) 3086 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb, 3087 struct net_device *netdev) 3088 { 3089 struct e1000_adapter *adapter = netdev_priv(netdev); 3090 struct e1000_hw *hw = &adapter->hw; 3091 struct e1000_tx_ring *tx_ring; 3092 unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD; 3093 unsigned int max_txd_pwr = E1000_MAX_TXD_PWR; 3094 unsigned int tx_flags = 0; 3095 unsigned int len = skb_headlen(skb); 3096 unsigned int nr_frags; 3097 unsigned int mss; 3098 int count = 0; 3099 int tso; 3100 unsigned int f; 3101 3102 /* This goes back to the question of how to logically map a Tx queue 3103 * to a flow. Right now, performance is impacted slightly negatively 3104 * if using multiple Tx queues. If the stack breaks away from a 3105 * single qdisc implementation, we can look at this again. 3106 */ 3107 tx_ring = adapter->tx_ring; 3108 3109 if (unlikely(skb->len <= 0)) { 3110 dev_kfree_skb_any(skb); 3111 return NETDEV_TX_OK; 3112 } 3113 3114 /* On PCI/PCI-X HW, if packet size is less than ETH_ZLEN, 3115 * packets may get corrupted during padding by HW. 3116 * To WA this issue, pad all small packets manually. 3117 */ 3118 if (skb->len < ETH_ZLEN) { 3119 if (skb_pad(skb, ETH_ZLEN - skb->len)) 3120 return NETDEV_TX_OK; 3121 skb->len = ETH_ZLEN; 3122 skb_set_tail_pointer(skb, ETH_ZLEN); 3123 } 3124 3125 mss = skb_shinfo(skb)->gso_size; 3126 /* The controller does a simple calculation to 3127 * make sure there is enough room in the FIFO before 3128 * initiating the DMA for each buffer. The calc is: 3129 * 4 = ceil(buffer len/mss). To make sure we don't 3130 * overrun the FIFO, adjust the max buffer len if mss 3131 * drops. 3132 */ 3133 if (mss) { 3134 u8 hdr_len; 3135 max_per_txd = min(mss << 2, max_per_txd); 3136 max_txd_pwr = fls(max_per_txd) - 1; 3137 3138 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb); 3139 if (skb->data_len && hdr_len == len) { 3140 switch (hw->mac_type) { 3141 unsigned int pull_size; 3142 case e1000_82544: 3143 /* Make sure we have room to chop off 4 bytes, 3144 * and that the end alignment will work out to 3145 * this hardware's requirements 3146 * NOTE: this is a TSO only workaround 3147 * if end byte alignment not correct move us 3148 * into the next dword 3149 */ 3150 if ((unsigned long)(skb_tail_pointer(skb) - 1) 3151 & 4) 3152 break; 3153 /* fall through */ 3154 pull_size = min((unsigned int)4, skb->data_len); 3155 if (!__pskb_pull_tail(skb, pull_size)) { 3156 e_err(drv, "__pskb_pull_tail " 3157 "failed.\n"); 3158 dev_kfree_skb_any(skb); 3159 return NETDEV_TX_OK; 3160 } 3161 len = skb_headlen(skb); 3162 break; 3163 default: 3164 /* do nothing */ 3165 break; 3166 } 3167 } 3168 } 3169 3170 /* reserve a descriptor for the offload context */ 3171 if ((mss) || (skb->ip_summed == CHECKSUM_PARTIAL)) 3172 count++; 3173 count++; 3174 3175 /* Controller Erratum workaround */ 3176 if (!skb->data_len && tx_ring->last_tx_tso && !skb_is_gso(skb)) 3177 count++; 3178 3179 count += TXD_USE_COUNT(len, max_txd_pwr); 3180 3181 if (adapter->pcix_82544) 3182 count++; 3183 3184 /* work-around for errata 10 and it applies to all controllers 3185 * in PCI-X mode, so add one more descriptor to the count 3186 */ 3187 if (unlikely((hw->bus_type == e1000_bus_type_pcix) && 3188 (len > 2015))) 3189 count++; 3190 3191 nr_frags = skb_shinfo(skb)->nr_frags; 3192 for (f = 0; f < nr_frags; f++) 3193 count += TXD_USE_COUNT(skb_frag_size(&skb_shinfo(skb)->frags[f]), 3194 max_txd_pwr); 3195 if (adapter->pcix_82544) 3196 count += nr_frags; 3197 3198 /* need: count + 2 desc gap to keep tail from touching 3199 * head, otherwise try next time 3200 */ 3201 if (unlikely(e1000_maybe_stop_tx(netdev, tx_ring, count + 2))) 3202 return NETDEV_TX_BUSY; 3203 3204 if (unlikely((hw->mac_type == e1000_82547) && 3205 (e1000_82547_fifo_workaround(adapter, skb)))) { 3206 netif_stop_queue(netdev); 3207 if (!test_bit(__E1000_DOWN, &adapter->flags)) 3208 schedule_delayed_work(&adapter->fifo_stall_task, 1); 3209 return NETDEV_TX_BUSY; 3210 } 3211 3212 if (vlan_tx_tag_present(skb)) { 3213 tx_flags |= E1000_TX_FLAGS_VLAN; 3214 tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT); 3215 } 3216 3217 first = tx_ring->next_to_use; 3218 3219 tso = e1000_tso(adapter, tx_ring, skb); 3220 if (tso < 0) { 3221 dev_kfree_skb_any(skb); 3222 return NETDEV_TX_OK; 3223 } 3224 3225 if (likely(tso)) { 3226 if (likely(hw->mac_type != e1000_82544)) 3227 tx_ring->last_tx_tso = true; 3228 tx_flags |= E1000_TX_FLAGS_TSO; 3229 } else if (likely(e1000_tx_csum(adapter, tx_ring, skb))) 3230 tx_flags |= E1000_TX_FLAGS_CSUM; 3231 3232 if (likely(skb->protocol == htons(ETH_P_IP))) 3233 tx_flags |= E1000_TX_FLAGS_IPV4; 3234 3235 if (unlikely(skb->no_fcs)) 3236 tx_flags |= E1000_TX_FLAGS_NO_FCS; 3237 3238 count = e1000_tx_map(adapter, tx_ring, skb, first, max_per_txd, 3239 nr_frags, mss); 3240 3241 if (count) { 3242 netdev_sent_queue(netdev, skb->len); 3243 skb_tx_timestamp(skb); 3244 3245 e1000_tx_queue(adapter, tx_ring, tx_flags, count); 3246 /* Make sure there is space in the ring for the next send. */ 3247 e1000_maybe_stop_tx(netdev, tx_ring, MAX_SKB_FRAGS + 2); 3248 3249 } else { 3250 dev_kfree_skb_any(skb); 3251 tx_ring->buffer_info[first].time_stamp = 0; 3252 tx_ring->next_to_use = first; 3253 } 3254 3255 return NETDEV_TX_OK; 3256 } 3257 3258 #define NUM_REGS 38 /* 1 based count */ 3259 static void e1000_regdump(struct e1000_adapter *adapter) 3260 { 3261 struct e1000_hw *hw = &adapter->hw; 3262 u32 regs[NUM_REGS]; 3263 u32 *regs_buff = regs; 3264 int i = 0; 3265 3266 static const char * const reg_name[] = { 3267 "CTRL", "STATUS", 3268 "RCTL", "RDLEN", "RDH", "RDT", "RDTR", 3269 "TCTL", "TDBAL", "TDBAH", "TDLEN", "TDH", "TDT", 3270 "TIDV", "TXDCTL", "TADV", "TARC0", 3271 "TDBAL1", "TDBAH1", "TDLEN1", "TDH1", "TDT1", 3272 "TXDCTL1", "TARC1", 3273 "CTRL_EXT", "ERT", "RDBAL", "RDBAH", 3274 "TDFH", "TDFT", "TDFHS", "TDFTS", "TDFPC", 3275 "RDFH", "RDFT", "RDFHS", "RDFTS", "RDFPC" 3276 }; 3277 3278 regs_buff[0] = er32(CTRL); 3279 regs_buff[1] = er32(STATUS); 3280 3281 regs_buff[2] = er32(RCTL); 3282 regs_buff[3] = er32(RDLEN); 3283 regs_buff[4] = er32(RDH); 3284 regs_buff[5] = er32(RDT); 3285 regs_buff[6] = er32(RDTR); 3286 3287 regs_buff[7] = er32(TCTL); 3288 regs_buff[8] = er32(TDBAL); 3289 regs_buff[9] = er32(TDBAH); 3290 regs_buff[10] = er32(TDLEN); 3291 regs_buff[11] = er32(TDH); 3292 regs_buff[12] = er32(TDT); 3293 regs_buff[13] = er32(TIDV); 3294 regs_buff[14] = er32(TXDCTL); 3295 regs_buff[15] = er32(TADV); 3296 regs_buff[16] = er32(TARC0); 3297 3298 regs_buff[17] = er32(TDBAL1); 3299 regs_buff[18] = er32(TDBAH1); 3300 regs_buff[19] = er32(TDLEN1); 3301 regs_buff[20] = er32(TDH1); 3302 regs_buff[21] = er32(TDT1); 3303 regs_buff[22] = er32(TXDCTL1); 3304 regs_buff[23] = er32(TARC1); 3305 regs_buff[24] = er32(CTRL_EXT); 3306 regs_buff[25] = er32(ERT); 3307 regs_buff[26] = er32(RDBAL0); 3308 regs_buff[27] = er32(RDBAH0); 3309 regs_buff[28] = er32(TDFH); 3310 regs_buff[29] = er32(TDFT); 3311 regs_buff[30] = er32(TDFHS); 3312 regs_buff[31] = er32(TDFTS); 3313 regs_buff[32] = er32(TDFPC); 3314 regs_buff[33] = er32(RDFH); 3315 regs_buff[34] = er32(RDFT); 3316 regs_buff[35] = er32(RDFHS); 3317 regs_buff[36] = er32(RDFTS); 3318 regs_buff[37] = er32(RDFPC); 3319 3320 pr_info("Register dump\n"); 3321 for (i = 0; i < NUM_REGS; i++) 3322 pr_info("%-15s %08x\n", reg_name[i], regs_buff[i]); 3323 } 3324 3325 /* 3326 * e1000_dump: Print registers, tx ring and rx ring 3327 */ 3328 static void e1000_dump(struct e1000_adapter *adapter) 3329 { 3330 /* this code doesn't handle multiple rings */ 3331 struct e1000_tx_ring *tx_ring = adapter->tx_ring; 3332 struct e1000_rx_ring *rx_ring = adapter->rx_ring; 3333 int i; 3334 3335 if (!netif_msg_hw(adapter)) 3336 return; 3337 3338 /* Print Registers */ 3339 e1000_regdump(adapter); 3340 3341 /* transmit dump */ 3342 pr_info("TX Desc ring0 dump\n"); 3343 3344 /* Transmit Descriptor Formats - DEXT[29] is 0 (Legacy) or 1 (Extended) 3345 * 3346 * Legacy Transmit Descriptor 3347 * +--------------------------------------------------------------+ 3348 * 0 | Buffer Address [63:0] (Reserved on Write Back) | 3349 * +--------------------------------------------------------------+ 3350 * 8 | Special | CSS | Status | CMD | CSO | Length | 3351 * +--------------------------------------------------------------+ 3352 * 63 48 47 36 35 32 31 24 23 16 15 0 3353 * 3354 * Extended Context Descriptor (DTYP=0x0) for TSO or checksum offload 3355 * 63 48 47 40 39 32 31 16 15 8 7 0 3356 * +----------------------------------------------------------------+ 3357 * 0 | TUCSE | TUCS0 | TUCSS | IPCSE | IPCS0 | IPCSS | 3358 * +----------------------------------------------------------------+ 3359 * 8 | MSS | HDRLEN | RSV | STA | TUCMD | DTYP | PAYLEN | 3360 * +----------------------------------------------------------------+ 3361 * 63 48 47 40 39 36 35 32 31 24 23 20 19 0 3362 * 3363 * Extended Data Descriptor (DTYP=0x1) 3364 * +----------------------------------------------------------------+ 3365 * 0 | Buffer Address [63:0] | 3366 * +----------------------------------------------------------------+ 3367 * 8 | VLAN tag | POPTS | Rsvd | Status | Command | DTYP | DTALEN | 3368 * +----------------------------------------------------------------+ 3369 * 63 48 47 40 39 36 35 32 31 24 23 20 19 0 3370 */ 3371 pr_info("Tc[desc] [Ce CoCsIpceCoS] [MssHlRSCm0Plen] [bi->dma ] leng ntw timestmp bi->skb\n"); 3372 pr_info("Td[desc] [address 63:0 ] [VlaPoRSCm1Dlen] [bi->dma ] leng ntw timestmp bi->skb\n"); 3373 3374 if (!netif_msg_tx_done(adapter)) 3375 goto rx_ring_summary; 3376 3377 for (i = 0; tx_ring->desc && (i < tx_ring->count); i++) { 3378 struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i); 3379 struct e1000_buffer *buffer_info = &tx_ring->buffer_info[i]; 3380 struct my_u { __le64 a; __le64 b; }; 3381 struct my_u *u = (struct my_u *)tx_desc; 3382 const char *type; 3383 3384 if (i == tx_ring->next_to_use && i == tx_ring->next_to_clean) 3385 type = "NTC/U"; 3386 else if (i == tx_ring->next_to_use) 3387 type = "NTU"; 3388 else if (i == tx_ring->next_to_clean) 3389 type = "NTC"; 3390 else 3391 type = ""; 3392 3393 pr_info("T%c[0x%03X] %016llX %016llX %016llX %04X %3X %016llX %p %s\n", 3394 ((le64_to_cpu(u->b) & (1<<20)) ? 'd' : 'c'), i, 3395 le64_to_cpu(u->a), le64_to_cpu(u->b), 3396 (u64)buffer_info->dma, buffer_info->length, 3397 buffer_info->next_to_watch, 3398 (u64)buffer_info->time_stamp, buffer_info->skb, type); 3399 } 3400 3401 rx_ring_summary: 3402 /* receive dump */ 3403 pr_info("\nRX Desc ring dump\n"); 3404 3405 /* Legacy Receive Descriptor Format 3406 * 3407 * +-----------------------------------------------------+ 3408 * | Buffer Address [63:0] | 3409 * +-----------------------------------------------------+ 3410 * | VLAN Tag | Errors | Status 0 | Packet csum | Length | 3411 * +-----------------------------------------------------+ 3412 * 63 48 47 40 39 32 31 16 15 0 3413 */ 3414 pr_info("R[desc] [address 63:0 ] [vl er S cks ln] [bi->dma ] [bi->skb]\n"); 3415 3416 if (!netif_msg_rx_status(adapter)) 3417 goto exit; 3418 3419 for (i = 0; rx_ring->desc && (i < rx_ring->count); i++) { 3420 struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rx_ring, i); 3421 struct e1000_buffer *buffer_info = &rx_ring->buffer_info[i]; 3422 struct my_u { __le64 a; __le64 b; }; 3423 struct my_u *u = (struct my_u *)rx_desc; 3424 const char *type; 3425 3426 if (i == rx_ring->next_to_use) 3427 type = "NTU"; 3428 else if (i == rx_ring->next_to_clean) 3429 type = "NTC"; 3430 else 3431 type = ""; 3432 3433 pr_info("R[0x%03X] %016llX %016llX %016llX %p %s\n", 3434 i, le64_to_cpu(u->a), le64_to_cpu(u->b), 3435 (u64)buffer_info->dma, buffer_info->skb, type); 3436 } /* for */ 3437 3438 /* dump the descriptor caches */ 3439 /* rx */ 3440 pr_info("Rx descriptor cache in 64bit format\n"); 3441 for (i = 0x6000; i <= 0x63FF ; i += 0x10) { 3442 pr_info("R%04X: %08X|%08X %08X|%08X\n", 3443 i, 3444 readl(adapter->hw.hw_addr + i+4), 3445 readl(adapter->hw.hw_addr + i), 3446 readl(adapter->hw.hw_addr + i+12), 3447 readl(adapter->hw.hw_addr + i+8)); 3448 } 3449 /* tx */ 3450 pr_info("Tx descriptor cache in 64bit format\n"); 3451 for (i = 0x7000; i <= 0x73FF ; i += 0x10) { 3452 pr_info("T%04X: %08X|%08X %08X|%08X\n", 3453 i, 3454 readl(adapter->hw.hw_addr + i+4), 3455 readl(adapter->hw.hw_addr + i), 3456 readl(adapter->hw.hw_addr + i+12), 3457 readl(adapter->hw.hw_addr + i+8)); 3458 } 3459 exit: 3460 return; 3461 } 3462 3463 /** 3464 * e1000_tx_timeout - Respond to a Tx Hang 3465 * @netdev: network interface device structure 3466 **/ 3467 static void e1000_tx_timeout(struct net_device *netdev) 3468 { 3469 struct e1000_adapter *adapter = netdev_priv(netdev); 3470 3471 /* Do the reset outside of interrupt context */ 3472 adapter->tx_timeout_count++; 3473 schedule_work(&adapter->reset_task); 3474 } 3475 3476 static void e1000_reset_task(struct work_struct *work) 3477 { 3478 struct e1000_adapter *adapter = 3479 container_of(work, struct e1000_adapter, reset_task); 3480 3481 e_err(drv, "Reset adapter\n"); 3482 e1000_reinit_locked(adapter); 3483 } 3484 3485 /** 3486 * e1000_get_stats - Get System Network Statistics 3487 * @netdev: network interface device structure 3488 * 3489 * Returns the address of the device statistics structure. 3490 * The statistics are actually updated from the watchdog. 3491 **/ 3492 static struct net_device_stats *e1000_get_stats(struct net_device *netdev) 3493 { 3494 /* only return the current stats */ 3495 return &netdev->stats; 3496 } 3497 3498 /** 3499 * e1000_change_mtu - Change the Maximum Transfer Unit 3500 * @netdev: network interface device structure 3501 * @new_mtu: new value for maximum frame size 3502 * 3503 * Returns 0 on success, negative on failure 3504 **/ 3505 static int e1000_change_mtu(struct net_device *netdev, int new_mtu) 3506 { 3507 struct e1000_adapter *adapter = netdev_priv(netdev); 3508 struct e1000_hw *hw = &adapter->hw; 3509 int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE; 3510 3511 if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) || 3512 (max_frame > MAX_JUMBO_FRAME_SIZE)) { 3513 e_err(probe, "Invalid MTU setting\n"); 3514 return -EINVAL; 3515 } 3516 3517 /* Adapter-specific max frame size limits. */ 3518 switch (hw->mac_type) { 3519 case e1000_undefined ... e1000_82542_rev2_1: 3520 if (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)) { 3521 e_err(probe, "Jumbo Frames not supported.\n"); 3522 return -EINVAL; 3523 } 3524 break; 3525 default: 3526 /* Capable of supporting up to MAX_JUMBO_FRAME_SIZE limit. */ 3527 break; 3528 } 3529 3530 while (test_and_set_bit(__E1000_RESETTING, &adapter->flags)) 3531 msleep(1); 3532 /* e1000_down has a dependency on max_frame_size */ 3533 hw->max_frame_size = max_frame; 3534 if (netif_running(netdev)) 3535 e1000_down(adapter); 3536 3537 /* NOTE: netdev_alloc_skb reserves 16 bytes, and typically NET_IP_ALIGN 3538 * means we reserve 2 more, this pushes us to allocate from the next 3539 * larger slab size. 3540 * i.e. RXBUFFER_2048 --> size-4096 slab 3541 * however with the new *_jumbo_rx* routines, jumbo receives will use 3542 * fragmented skbs 3543 */ 3544 3545 if (max_frame <= E1000_RXBUFFER_2048) 3546 adapter->rx_buffer_len = E1000_RXBUFFER_2048; 3547 else 3548 #if (PAGE_SIZE >= E1000_RXBUFFER_16384) 3549 adapter->rx_buffer_len = E1000_RXBUFFER_16384; 3550 #elif (PAGE_SIZE >= E1000_RXBUFFER_4096) 3551 adapter->rx_buffer_len = PAGE_SIZE; 3552 #endif 3553 3554 /* adjust allocation if LPE protects us, and we aren't using SBP */ 3555 if (!hw->tbi_compatibility_on && 3556 ((max_frame == (ETH_FRAME_LEN + ETH_FCS_LEN)) || 3557 (max_frame == MAXIMUM_ETHERNET_VLAN_SIZE))) 3558 adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE; 3559 3560 pr_info("%s changing MTU from %d to %d\n", 3561 netdev->name, netdev->mtu, new_mtu); 3562 netdev->mtu = new_mtu; 3563 3564 if (netif_running(netdev)) 3565 e1000_up(adapter); 3566 else 3567 e1000_reset(adapter); 3568 3569 clear_bit(__E1000_RESETTING, &adapter->flags); 3570 3571 return 0; 3572 } 3573 3574 /** 3575 * e1000_update_stats - Update the board statistics counters 3576 * @adapter: board private structure 3577 **/ 3578 void e1000_update_stats(struct e1000_adapter *adapter) 3579 { 3580 struct net_device *netdev = adapter->netdev; 3581 struct e1000_hw *hw = &adapter->hw; 3582 struct pci_dev *pdev = adapter->pdev; 3583 unsigned long flags; 3584 u16 phy_tmp; 3585 3586 #define PHY_IDLE_ERROR_COUNT_MASK 0x00FF 3587 3588 /* Prevent stats update while adapter is being reset, or if the pci 3589 * connection is down. 3590 */ 3591 if (adapter->link_speed == 0) 3592 return; 3593 if (pci_channel_offline(pdev)) 3594 return; 3595 3596 spin_lock_irqsave(&adapter->stats_lock, flags); 3597 3598 /* these counters are modified from e1000_tbi_adjust_stats, 3599 * called from the interrupt context, so they must only 3600 * be written while holding adapter->stats_lock 3601 */ 3602 3603 adapter->stats.crcerrs += er32(CRCERRS); 3604 adapter->stats.gprc += er32(GPRC); 3605 adapter->stats.gorcl += er32(GORCL); 3606 adapter->stats.gorch += er32(GORCH); 3607 adapter->stats.bprc += er32(BPRC); 3608 adapter->stats.mprc += er32(MPRC); 3609 adapter->stats.roc += er32(ROC); 3610 3611 adapter->stats.prc64 += er32(PRC64); 3612 adapter->stats.prc127 += er32(PRC127); 3613 adapter->stats.prc255 += er32(PRC255); 3614 adapter->stats.prc511 += er32(PRC511); 3615 adapter->stats.prc1023 += er32(PRC1023); 3616 adapter->stats.prc1522 += er32(PRC1522); 3617 3618 adapter->stats.symerrs += er32(SYMERRS); 3619 adapter->stats.mpc += er32(MPC); 3620 adapter->stats.scc += er32(SCC); 3621 adapter->stats.ecol += er32(ECOL); 3622 adapter->stats.mcc += er32(MCC); 3623 adapter->stats.latecol += er32(LATECOL); 3624 adapter->stats.dc += er32(DC); 3625 adapter->stats.sec += er32(SEC); 3626 adapter->stats.rlec += er32(RLEC); 3627 adapter->stats.xonrxc += er32(XONRXC); 3628 adapter->stats.xontxc += er32(XONTXC); 3629 adapter->stats.xoffrxc += er32(XOFFRXC); 3630 adapter->stats.xofftxc += er32(XOFFTXC); 3631 adapter->stats.fcruc += er32(FCRUC); 3632 adapter->stats.gptc += er32(GPTC); 3633 adapter->stats.gotcl += er32(GOTCL); 3634 adapter->stats.gotch += er32(GOTCH); 3635 adapter->stats.rnbc += er32(RNBC); 3636 adapter->stats.ruc += er32(RUC); 3637 adapter->stats.rfc += er32(RFC); 3638 adapter->stats.rjc += er32(RJC); 3639 adapter->stats.torl += er32(TORL); 3640 adapter->stats.torh += er32(TORH); 3641 adapter->stats.totl += er32(TOTL); 3642 adapter->stats.toth += er32(TOTH); 3643 adapter->stats.tpr += er32(TPR); 3644 3645 adapter->stats.ptc64 += er32(PTC64); 3646 adapter->stats.ptc127 += er32(PTC127); 3647 adapter->stats.ptc255 += er32(PTC255); 3648 adapter->stats.ptc511 += er32(PTC511); 3649 adapter->stats.ptc1023 += er32(PTC1023); 3650 adapter->stats.ptc1522 += er32(PTC1522); 3651 3652 adapter->stats.mptc += er32(MPTC); 3653 adapter->stats.bptc += er32(BPTC); 3654 3655 /* used for adaptive IFS */ 3656 3657 hw->tx_packet_delta = er32(TPT); 3658 adapter->stats.tpt += hw->tx_packet_delta; 3659 hw->collision_delta = er32(COLC); 3660 adapter->stats.colc += hw->collision_delta; 3661 3662 if (hw->mac_type >= e1000_82543) { 3663 adapter->stats.algnerrc += er32(ALGNERRC); 3664 adapter->stats.rxerrc += er32(RXERRC); 3665 adapter->stats.tncrs += er32(TNCRS); 3666 adapter->stats.cexterr += er32(CEXTERR); 3667 adapter->stats.tsctc += er32(TSCTC); 3668 adapter->stats.tsctfc += er32(TSCTFC); 3669 } 3670 3671 /* Fill out the OS statistics structure */ 3672 netdev->stats.multicast = adapter->stats.mprc; 3673 netdev->stats.collisions = adapter->stats.colc; 3674 3675 /* Rx Errors */ 3676 3677 /* RLEC on some newer hardware can be incorrect so build 3678 * our own version based on RUC and ROC 3679 */ 3680 netdev->stats.rx_errors = adapter->stats.rxerrc + 3681 adapter->stats.crcerrs + adapter->stats.algnerrc + 3682 adapter->stats.ruc + adapter->stats.roc + 3683 adapter->stats.cexterr; 3684 adapter->stats.rlerrc = adapter->stats.ruc + adapter->stats.roc; 3685 netdev->stats.rx_length_errors = adapter->stats.rlerrc; 3686 netdev->stats.rx_crc_errors = adapter->stats.crcerrs; 3687 netdev->stats.rx_frame_errors = adapter->stats.algnerrc; 3688 netdev->stats.rx_missed_errors = adapter->stats.mpc; 3689 3690 /* Tx Errors */ 3691 adapter->stats.txerrc = adapter->stats.ecol + adapter->stats.latecol; 3692 netdev->stats.tx_errors = adapter->stats.txerrc; 3693 netdev->stats.tx_aborted_errors = adapter->stats.ecol; 3694 netdev->stats.tx_window_errors = adapter->stats.latecol; 3695 netdev->stats.tx_carrier_errors = adapter->stats.tncrs; 3696 if (hw->bad_tx_carr_stats_fd && 3697 adapter->link_duplex == FULL_DUPLEX) { 3698 netdev->stats.tx_carrier_errors = 0; 3699 adapter->stats.tncrs = 0; 3700 } 3701 3702 /* Tx Dropped needs to be maintained elsewhere */ 3703 3704 /* Phy Stats */ 3705 if (hw->media_type == e1000_media_type_copper) { 3706 if ((adapter->link_speed == SPEED_1000) && 3707 (!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) { 3708 phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK; 3709 adapter->phy_stats.idle_errors += phy_tmp; 3710 } 3711 3712 if ((hw->mac_type <= e1000_82546) && 3713 (hw->phy_type == e1000_phy_m88) && 3714 !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp)) 3715 adapter->phy_stats.receive_errors += phy_tmp; 3716 } 3717 3718 /* Management Stats */ 3719 if (hw->has_smbus) { 3720 adapter->stats.mgptc += er32(MGTPTC); 3721 adapter->stats.mgprc += er32(MGTPRC); 3722 adapter->stats.mgpdc += er32(MGTPDC); 3723 } 3724 3725 spin_unlock_irqrestore(&adapter->stats_lock, flags); 3726 } 3727 3728 /** 3729 * e1000_intr - Interrupt Handler 3730 * @irq: interrupt number 3731 * @data: pointer to a network interface device structure 3732 **/ 3733 static irqreturn_t e1000_intr(int irq, void *data) 3734 { 3735 struct net_device *netdev = data; 3736 struct e1000_adapter *adapter = netdev_priv(netdev); 3737 struct e1000_hw *hw = &adapter->hw; 3738 u32 icr = er32(ICR); 3739 3740 if (unlikely((!icr))) 3741 return IRQ_NONE; /* Not our interrupt */ 3742 3743 /* we might have caused the interrupt, but the above 3744 * read cleared it, and just in case the driver is 3745 * down there is nothing to do so return handled 3746 */ 3747 if (unlikely(test_bit(__E1000_DOWN, &adapter->flags))) 3748 return IRQ_HANDLED; 3749 3750 if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) { 3751 hw->get_link_status = 1; 3752 /* guard against interrupt when we're going down */ 3753 if (!test_bit(__E1000_DOWN, &adapter->flags)) 3754 schedule_delayed_work(&adapter->watchdog_task, 1); 3755 } 3756 3757 /* disable interrupts, without the synchronize_irq bit */ 3758 ew32(IMC, ~0); 3759 E1000_WRITE_FLUSH(); 3760 3761 if (likely(napi_schedule_prep(&adapter->napi))) { 3762 adapter->total_tx_bytes = 0; 3763 adapter->total_tx_packets = 0; 3764 adapter->total_rx_bytes = 0; 3765 adapter->total_rx_packets = 0; 3766 __napi_schedule(&adapter->napi); 3767 } else { 3768 /* this really should not happen! if it does it is basically a 3769 * bug, but not a hard error, so enable ints and continue 3770 */ 3771 if (!test_bit(__E1000_DOWN, &adapter->flags)) 3772 e1000_irq_enable(adapter); 3773 } 3774 3775 return IRQ_HANDLED; 3776 } 3777 3778 /** 3779 * e1000_clean - NAPI Rx polling callback 3780 * @adapter: board private structure 3781 **/ 3782 static int e1000_clean(struct napi_struct *napi, int budget) 3783 { 3784 struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter, 3785 napi); 3786 int tx_clean_complete = 0, work_done = 0; 3787 3788 tx_clean_complete = e1000_clean_tx_irq(adapter, &adapter->tx_ring[0]); 3789 3790 adapter->clean_rx(adapter, &adapter->rx_ring[0], &work_done, budget); 3791 3792 if (!tx_clean_complete) 3793 work_done = budget; 3794 3795 /* If budget not fully consumed, exit the polling mode */ 3796 if (work_done < budget) { 3797 if (likely(adapter->itr_setting & 3)) 3798 e1000_set_itr(adapter); 3799 napi_complete(napi); 3800 if (!test_bit(__E1000_DOWN, &adapter->flags)) 3801 e1000_irq_enable(adapter); 3802 } 3803 3804 return work_done; 3805 } 3806 3807 /** 3808 * e1000_clean_tx_irq - Reclaim resources after transmit completes 3809 * @adapter: board private structure 3810 **/ 3811 static bool e1000_clean_tx_irq(struct e1000_adapter *adapter, 3812 struct e1000_tx_ring *tx_ring) 3813 { 3814 struct e1000_hw *hw = &adapter->hw; 3815 struct net_device *netdev = adapter->netdev; 3816 struct e1000_tx_desc *tx_desc, *eop_desc; 3817 struct e1000_buffer *buffer_info; 3818 unsigned int i, eop; 3819 unsigned int count = 0; 3820 unsigned int total_tx_bytes=0, total_tx_packets=0; 3821 unsigned int bytes_compl = 0, pkts_compl = 0; 3822 3823 i = tx_ring->next_to_clean; 3824 eop = tx_ring->buffer_info[i].next_to_watch; 3825 eop_desc = E1000_TX_DESC(*tx_ring, eop); 3826 3827 while ((eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) && 3828 (count < tx_ring->count)) { 3829 bool cleaned = false; 3830 rmb(); /* read buffer_info after eop_desc */ 3831 for ( ; !cleaned; count++) { 3832 tx_desc = E1000_TX_DESC(*tx_ring, i); 3833 buffer_info = &tx_ring->buffer_info[i]; 3834 cleaned = (i == eop); 3835 3836 if (cleaned) { 3837 total_tx_packets += buffer_info->segs; 3838 total_tx_bytes += buffer_info->bytecount; 3839 if (buffer_info->skb) { 3840 bytes_compl += buffer_info->skb->len; 3841 pkts_compl++; 3842 } 3843 3844 } 3845 e1000_unmap_and_free_tx_resource(adapter, buffer_info); 3846 tx_desc->upper.data = 0; 3847 3848 if (unlikely(++i == tx_ring->count)) i = 0; 3849 } 3850 3851 eop = tx_ring->buffer_info[i].next_to_watch; 3852 eop_desc = E1000_TX_DESC(*tx_ring, eop); 3853 } 3854 3855 tx_ring->next_to_clean = i; 3856 3857 netdev_completed_queue(netdev, pkts_compl, bytes_compl); 3858 3859 #define TX_WAKE_THRESHOLD 32 3860 if (unlikely(count && netif_carrier_ok(netdev) && 3861 E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) { 3862 /* Make sure that anybody stopping the queue after this 3863 * sees the new next_to_clean. 3864 */ 3865 smp_mb(); 3866 3867 if (netif_queue_stopped(netdev) && 3868 !(test_bit(__E1000_DOWN, &adapter->flags))) { 3869 netif_wake_queue(netdev); 3870 ++adapter->restart_queue; 3871 } 3872 } 3873 3874 if (adapter->detect_tx_hung) { 3875 /* Detect a transmit hang in hardware, this serializes the 3876 * check with the clearing of time_stamp and movement of i 3877 */ 3878 adapter->detect_tx_hung = false; 3879 if (tx_ring->buffer_info[eop].time_stamp && 3880 time_after(jiffies, tx_ring->buffer_info[eop].time_stamp + 3881 (adapter->tx_timeout_factor * HZ)) && 3882 !(er32(STATUS) & E1000_STATUS_TXOFF)) { 3883 3884 /* detected Tx unit hang */ 3885 e_err(drv, "Detected Tx Unit Hang\n" 3886 " Tx Queue <%lu>\n" 3887 " TDH <%x>\n" 3888 " TDT <%x>\n" 3889 " next_to_use <%x>\n" 3890 " next_to_clean <%x>\n" 3891 "buffer_info[next_to_clean]\n" 3892 " time_stamp <%lx>\n" 3893 " next_to_watch <%x>\n" 3894 " jiffies <%lx>\n" 3895 " next_to_watch.status <%x>\n", 3896 (unsigned long)(tx_ring - adapter->tx_ring), 3897 readl(hw->hw_addr + tx_ring->tdh), 3898 readl(hw->hw_addr + tx_ring->tdt), 3899 tx_ring->next_to_use, 3900 tx_ring->next_to_clean, 3901 tx_ring->buffer_info[eop].time_stamp, 3902 eop, 3903 jiffies, 3904 eop_desc->upper.fields.status); 3905 e1000_dump(adapter); 3906 netif_stop_queue(netdev); 3907 } 3908 } 3909 adapter->total_tx_bytes += total_tx_bytes; 3910 adapter->total_tx_packets += total_tx_packets; 3911 netdev->stats.tx_bytes += total_tx_bytes; 3912 netdev->stats.tx_packets += total_tx_packets; 3913 return count < tx_ring->count; 3914 } 3915 3916 /** 3917 * e1000_rx_checksum - Receive Checksum Offload for 82543 3918 * @adapter: board private structure 3919 * @status_err: receive descriptor status and error fields 3920 * @csum: receive descriptor csum field 3921 * @sk_buff: socket buffer with received data 3922 **/ 3923 static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err, 3924 u32 csum, struct sk_buff *skb) 3925 { 3926 struct e1000_hw *hw = &adapter->hw; 3927 u16 status = (u16)status_err; 3928 u8 errors = (u8)(status_err >> 24); 3929 3930 skb_checksum_none_assert(skb); 3931 3932 /* 82543 or newer only */ 3933 if (unlikely(hw->mac_type < e1000_82543)) return; 3934 /* Ignore Checksum bit is set */ 3935 if (unlikely(status & E1000_RXD_STAT_IXSM)) return; 3936 /* TCP/UDP checksum error bit is set */ 3937 if (unlikely(errors & E1000_RXD_ERR_TCPE)) { 3938 /* let the stack verify checksum errors */ 3939 adapter->hw_csum_err++; 3940 return; 3941 } 3942 /* TCP/UDP Checksum has not been calculated */ 3943 if (!(status & E1000_RXD_STAT_TCPCS)) 3944 return; 3945 3946 /* It must be a TCP or UDP packet with a valid checksum */ 3947 if (likely(status & E1000_RXD_STAT_TCPCS)) { 3948 /* TCP checksum is good */ 3949 skb->ip_summed = CHECKSUM_UNNECESSARY; 3950 } 3951 adapter->hw_csum_good++; 3952 } 3953 3954 /** 3955 * e1000_consume_page - helper function 3956 **/ 3957 static void e1000_consume_page(struct e1000_buffer *bi, struct sk_buff *skb, 3958 u16 length) 3959 { 3960 bi->page = NULL; 3961 skb->len += length; 3962 skb->data_len += length; 3963 skb->truesize += PAGE_SIZE; 3964 } 3965 3966 /** 3967 * e1000_receive_skb - helper function to handle rx indications 3968 * @adapter: board private structure 3969 * @status: descriptor status field as written by hardware 3970 * @vlan: descriptor vlan field as written by hardware (no le/be conversion) 3971 * @skb: pointer to sk_buff to be indicated to stack 3972 */ 3973 static void e1000_receive_skb(struct e1000_adapter *adapter, u8 status, 3974 __le16 vlan, struct sk_buff *skb) 3975 { 3976 skb->protocol = eth_type_trans(skb, adapter->netdev); 3977 3978 if (status & E1000_RXD_STAT_VP) { 3979 u16 vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK; 3980 3981 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid); 3982 } 3983 napi_gro_receive(&adapter->napi, skb); 3984 } 3985 3986 /** 3987 * e1000_clean_jumbo_rx_irq - Send received data up the network stack; legacy 3988 * @adapter: board private structure 3989 * @rx_ring: ring to clean 3990 * @work_done: amount of napi work completed this call 3991 * @work_to_do: max amount of work allowed for this call to do 3992 * 3993 * the return value indicates whether actual cleaning was done, there 3994 * is no guarantee that everything was cleaned 3995 */ 3996 static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter, 3997 struct e1000_rx_ring *rx_ring, 3998 int *work_done, int work_to_do) 3999 { 4000 struct e1000_hw *hw = &adapter->hw; 4001 struct net_device *netdev = adapter->netdev; 4002 struct pci_dev *pdev = adapter->pdev; 4003 struct e1000_rx_desc *rx_desc, *next_rxd; 4004 struct e1000_buffer *buffer_info, *next_buffer; 4005 unsigned long irq_flags; 4006 u32 length; 4007 unsigned int i; 4008 int cleaned_count = 0; 4009 bool cleaned = false; 4010 unsigned int total_rx_bytes=0, total_rx_packets=0; 4011 4012 i = rx_ring->next_to_clean; 4013 rx_desc = E1000_RX_DESC(*rx_ring, i); 4014 buffer_info = &rx_ring->buffer_info[i]; 4015 4016 while (rx_desc->status & E1000_RXD_STAT_DD) { 4017 struct sk_buff *skb; 4018 u8 status; 4019 4020 if (*work_done >= work_to_do) 4021 break; 4022 (*work_done)++; 4023 rmb(); /* read descriptor and rx_buffer_info after status DD */ 4024 4025 status = rx_desc->status; 4026 skb = buffer_info->skb; 4027 buffer_info->skb = NULL; 4028 4029 if (++i == rx_ring->count) i = 0; 4030 next_rxd = E1000_RX_DESC(*rx_ring, i); 4031 prefetch(next_rxd); 4032 4033 next_buffer = &rx_ring->buffer_info[i]; 4034 4035 cleaned = true; 4036 cleaned_count++; 4037 dma_unmap_page(&pdev->dev, buffer_info->dma, 4038 buffer_info->length, DMA_FROM_DEVICE); 4039 buffer_info->dma = 0; 4040 4041 length = le16_to_cpu(rx_desc->length); 4042 4043 /* errors is only valid for DD + EOP descriptors */ 4044 if (unlikely((status & E1000_RXD_STAT_EOP) && 4045 (rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK))) { 4046 u8 *mapped; 4047 u8 last_byte; 4048 4049 mapped = page_address(buffer_info->page); 4050 last_byte = *(mapped + length - 1); 4051 if (TBI_ACCEPT(hw, status, rx_desc->errors, length, 4052 last_byte)) { 4053 spin_lock_irqsave(&adapter->stats_lock, 4054 irq_flags); 4055 e1000_tbi_adjust_stats(hw, &adapter->stats, 4056 length, mapped); 4057 spin_unlock_irqrestore(&adapter->stats_lock, 4058 irq_flags); 4059 length--; 4060 } else { 4061 if (netdev->features & NETIF_F_RXALL) 4062 goto process_skb; 4063 /* recycle both page and skb */ 4064 buffer_info->skb = skb; 4065 /* an error means any chain goes out the window 4066 * too 4067 */ 4068 if (rx_ring->rx_skb_top) 4069 dev_kfree_skb(rx_ring->rx_skb_top); 4070 rx_ring->rx_skb_top = NULL; 4071 goto next_desc; 4072 } 4073 } 4074 4075 #define rxtop rx_ring->rx_skb_top 4076 process_skb: 4077 if (!(status & E1000_RXD_STAT_EOP)) { 4078 /* this descriptor is only the beginning (or middle) */ 4079 if (!rxtop) { 4080 /* this is the beginning of a chain */ 4081 rxtop = skb; 4082 skb_fill_page_desc(rxtop, 0, buffer_info->page, 4083 0, length); 4084 } else { 4085 /* this is the middle of a chain */ 4086 skb_fill_page_desc(rxtop, 4087 skb_shinfo(rxtop)->nr_frags, 4088 buffer_info->page, 0, length); 4089 /* re-use the skb, only consumed the page */ 4090 buffer_info->skb = skb; 4091 } 4092 e1000_consume_page(buffer_info, rxtop, length); 4093 goto next_desc; 4094 } else { 4095 if (rxtop) { 4096 /* end of the chain */ 4097 skb_fill_page_desc(rxtop, 4098 skb_shinfo(rxtop)->nr_frags, 4099 buffer_info->page, 0, length); 4100 /* re-use the current skb, we only consumed the 4101 * page 4102 */ 4103 buffer_info->skb = skb; 4104 skb = rxtop; 4105 rxtop = NULL; 4106 e1000_consume_page(buffer_info, skb, length); 4107 } else { 4108 /* no chain, got EOP, this buf is the packet 4109 * copybreak to save the put_page/alloc_page 4110 */ 4111 if (length <= copybreak && 4112 skb_tailroom(skb) >= length) { 4113 u8 *vaddr; 4114 vaddr = kmap_atomic(buffer_info->page); 4115 memcpy(skb_tail_pointer(skb), vaddr, 4116 length); 4117 kunmap_atomic(vaddr); 4118 /* re-use the page, so don't erase 4119 * buffer_info->page 4120 */ 4121 skb_put(skb, length); 4122 } else { 4123 skb_fill_page_desc(skb, 0, 4124 buffer_info->page, 0, 4125 length); 4126 e1000_consume_page(buffer_info, skb, 4127 length); 4128 } 4129 } 4130 } 4131 4132 /* Receive Checksum Offload XXX recompute due to CRC strip? */ 4133 e1000_rx_checksum(adapter, 4134 (u32)(status) | 4135 ((u32)(rx_desc->errors) << 24), 4136 le16_to_cpu(rx_desc->csum), skb); 4137 4138 total_rx_bytes += (skb->len - 4); /* don't count FCS */ 4139 if (likely(!(netdev->features & NETIF_F_RXFCS))) 4140 pskb_trim(skb, skb->len - 4); 4141 total_rx_packets++; 4142 4143 /* eth type trans needs skb->data to point to something */ 4144 if (!pskb_may_pull(skb, ETH_HLEN)) { 4145 e_err(drv, "pskb_may_pull failed.\n"); 4146 dev_kfree_skb(skb); 4147 goto next_desc; 4148 } 4149 4150 e1000_receive_skb(adapter, status, rx_desc->special, skb); 4151 4152 next_desc: 4153 rx_desc->status = 0; 4154 4155 /* return some buffers to hardware, one at a time is too slow */ 4156 if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) { 4157 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); 4158 cleaned_count = 0; 4159 } 4160 4161 /* use prefetched values */ 4162 rx_desc = next_rxd; 4163 buffer_info = next_buffer; 4164 } 4165 rx_ring->next_to_clean = i; 4166 4167 cleaned_count = E1000_DESC_UNUSED(rx_ring); 4168 if (cleaned_count) 4169 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); 4170 4171 adapter->total_rx_packets += total_rx_packets; 4172 adapter->total_rx_bytes += total_rx_bytes; 4173 netdev->stats.rx_bytes += total_rx_bytes; 4174 netdev->stats.rx_packets += total_rx_packets; 4175 return cleaned; 4176 } 4177 4178 /* this should improve performance for small packets with large amounts 4179 * of reassembly being done in the stack 4180 */ 4181 static void e1000_check_copybreak(struct net_device *netdev, 4182 struct e1000_buffer *buffer_info, 4183 u32 length, struct sk_buff **skb) 4184 { 4185 struct sk_buff *new_skb; 4186 4187 if (length > copybreak) 4188 return; 4189 4190 new_skb = netdev_alloc_skb_ip_align(netdev, length); 4191 if (!new_skb) 4192 return; 4193 4194 skb_copy_to_linear_data_offset(new_skb, -NET_IP_ALIGN, 4195 (*skb)->data - NET_IP_ALIGN, 4196 length + NET_IP_ALIGN); 4197 /* save the skb in buffer_info as good */ 4198 buffer_info->skb = *skb; 4199 *skb = new_skb; 4200 } 4201 4202 /** 4203 * e1000_clean_rx_irq - Send received data up the network stack; legacy 4204 * @adapter: board private structure 4205 * @rx_ring: ring to clean 4206 * @work_done: amount of napi work completed this call 4207 * @work_to_do: max amount of work allowed for this call to do 4208 */ 4209 static bool e1000_clean_rx_irq(struct e1000_adapter *adapter, 4210 struct e1000_rx_ring *rx_ring, 4211 int *work_done, int work_to_do) 4212 { 4213 struct e1000_hw *hw = &adapter->hw; 4214 struct net_device *netdev = adapter->netdev; 4215 struct pci_dev *pdev = adapter->pdev; 4216 struct e1000_rx_desc *rx_desc, *next_rxd; 4217 struct e1000_buffer *buffer_info, *next_buffer; 4218 unsigned long flags; 4219 u32 length; 4220 unsigned int i; 4221 int cleaned_count = 0; 4222 bool cleaned = false; 4223 unsigned int total_rx_bytes=0, total_rx_packets=0; 4224 4225 i = rx_ring->next_to_clean; 4226 rx_desc = E1000_RX_DESC(*rx_ring, i); 4227 buffer_info = &rx_ring->buffer_info[i]; 4228 4229 while (rx_desc->status & E1000_RXD_STAT_DD) { 4230 struct sk_buff *skb; 4231 u8 status; 4232 4233 if (*work_done >= work_to_do) 4234 break; 4235 (*work_done)++; 4236 rmb(); /* read descriptor and rx_buffer_info after status DD */ 4237 4238 status = rx_desc->status; 4239 skb = buffer_info->skb; 4240 buffer_info->skb = NULL; 4241 4242 prefetch(skb->data - NET_IP_ALIGN); 4243 4244 if (++i == rx_ring->count) i = 0; 4245 next_rxd = E1000_RX_DESC(*rx_ring, i); 4246 prefetch(next_rxd); 4247 4248 next_buffer = &rx_ring->buffer_info[i]; 4249 4250 cleaned = true; 4251 cleaned_count++; 4252 dma_unmap_single(&pdev->dev, buffer_info->dma, 4253 buffer_info->length, DMA_FROM_DEVICE); 4254 buffer_info->dma = 0; 4255 4256 length = le16_to_cpu(rx_desc->length); 4257 /* !EOP means multiple descriptors were used to store a single 4258 * packet, if thats the case we need to toss it. In fact, we 4259 * to toss every packet with the EOP bit clear and the next 4260 * frame that _does_ have the EOP bit set, as it is by 4261 * definition only a frame fragment 4262 */ 4263 if (unlikely(!(status & E1000_RXD_STAT_EOP))) 4264 adapter->discarding = true; 4265 4266 if (adapter->discarding) { 4267 /* All receives must fit into a single buffer */ 4268 e_dbg("Receive packet consumed multiple buffers\n"); 4269 /* recycle */ 4270 buffer_info->skb = skb; 4271 if (status & E1000_RXD_STAT_EOP) 4272 adapter->discarding = false; 4273 goto next_desc; 4274 } 4275 4276 if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) { 4277 u8 last_byte = *(skb->data + length - 1); 4278 if (TBI_ACCEPT(hw, status, rx_desc->errors, length, 4279 last_byte)) { 4280 spin_lock_irqsave(&adapter->stats_lock, flags); 4281 e1000_tbi_adjust_stats(hw, &adapter->stats, 4282 length, skb->data); 4283 spin_unlock_irqrestore(&adapter->stats_lock, 4284 flags); 4285 length--; 4286 } else { 4287 if (netdev->features & NETIF_F_RXALL) 4288 goto process_skb; 4289 /* recycle */ 4290 buffer_info->skb = skb; 4291 goto next_desc; 4292 } 4293 } 4294 4295 process_skb: 4296 total_rx_bytes += (length - 4); /* don't count FCS */ 4297 total_rx_packets++; 4298 4299 if (likely(!(netdev->features & NETIF_F_RXFCS))) 4300 /* adjust length to remove Ethernet CRC, this must be 4301 * done after the TBI_ACCEPT workaround above 4302 */ 4303 length -= 4; 4304 4305 e1000_check_copybreak(netdev, buffer_info, length, &skb); 4306 4307 skb_put(skb, length); 4308 4309 /* Receive Checksum Offload */ 4310 e1000_rx_checksum(adapter, 4311 (u32)(status) | 4312 ((u32)(rx_desc->errors) << 24), 4313 le16_to_cpu(rx_desc->csum), skb); 4314 4315 e1000_receive_skb(adapter, status, rx_desc->special, skb); 4316 4317 next_desc: 4318 rx_desc->status = 0; 4319 4320 /* return some buffers to hardware, one at a time is too slow */ 4321 if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) { 4322 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); 4323 cleaned_count = 0; 4324 } 4325 4326 /* use prefetched values */ 4327 rx_desc = next_rxd; 4328 buffer_info = next_buffer; 4329 } 4330 rx_ring->next_to_clean = i; 4331 4332 cleaned_count = E1000_DESC_UNUSED(rx_ring); 4333 if (cleaned_count) 4334 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); 4335 4336 adapter->total_rx_packets += total_rx_packets; 4337 adapter->total_rx_bytes += total_rx_bytes; 4338 netdev->stats.rx_bytes += total_rx_bytes; 4339 netdev->stats.rx_packets += total_rx_packets; 4340 return cleaned; 4341 } 4342 4343 /** 4344 * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers 4345 * @adapter: address of board private structure 4346 * @rx_ring: pointer to receive ring structure 4347 * @cleaned_count: number of buffers to allocate this pass 4348 **/ 4349 static void 4350 e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter, 4351 struct e1000_rx_ring *rx_ring, int cleaned_count) 4352 { 4353 struct net_device *netdev = adapter->netdev; 4354 struct pci_dev *pdev = adapter->pdev; 4355 struct e1000_rx_desc *rx_desc; 4356 struct e1000_buffer *buffer_info; 4357 struct sk_buff *skb; 4358 unsigned int i; 4359 unsigned int bufsz = 256 - 16 /*for skb_reserve */ ; 4360 4361 i = rx_ring->next_to_use; 4362 buffer_info = &rx_ring->buffer_info[i]; 4363 4364 while (cleaned_count--) { 4365 skb = buffer_info->skb; 4366 if (skb) { 4367 skb_trim(skb, 0); 4368 goto check_page; 4369 } 4370 4371 skb = netdev_alloc_skb_ip_align(netdev, bufsz); 4372 if (unlikely(!skb)) { 4373 /* Better luck next round */ 4374 adapter->alloc_rx_buff_failed++; 4375 break; 4376 } 4377 4378 buffer_info->skb = skb; 4379 buffer_info->length = adapter->rx_buffer_len; 4380 check_page: 4381 /* allocate a new page if necessary */ 4382 if (!buffer_info->page) { 4383 buffer_info->page = alloc_page(GFP_ATOMIC); 4384 if (unlikely(!buffer_info->page)) { 4385 adapter->alloc_rx_buff_failed++; 4386 break; 4387 } 4388 } 4389 4390 if (!buffer_info->dma) { 4391 buffer_info->dma = dma_map_page(&pdev->dev, 4392 buffer_info->page, 0, 4393 buffer_info->length, 4394 DMA_FROM_DEVICE); 4395 if (dma_mapping_error(&pdev->dev, buffer_info->dma)) { 4396 put_page(buffer_info->page); 4397 dev_kfree_skb(skb); 4398 buffer_info->page = NULL; 4399 buffer_info->skb = NULL; 4400 buffer_info->dma = 0; 4401 adapter->alloc_rx_buff_failed++; 4402 break; /* while !buffer_info->skb */ 4403 } 4404 } 4405 4406 rx_desc = E1000_RX_DESC(*rx_ring, i); 4407 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma); 4408 4409 if (unlikely(++i == rx_ring->count)) 4410 i = 0; 4411 buffer_info = &rx_ring->buffer_info[i]; 4412 } 4413 4414 if (likely(rx_ring->next_to_use != i)) { 4415 rx_ring->next_to_use = i; 4416 if (unlikely(i-- == 0)) 4417 i = (rx_ring->count - 1); 4418 4419 /* Force memory writes to complete before letting h/w 4420 * know there are new descriptors to fetch. (Only 4421 * applicable for weak-ordered memory model archs, 4422 * such as IA-64). 4423 */ 4424 wmb(); 4425 writel(i, adapter->hw.hw_addr + rx_ring->rdt); 4426 } 4427 } 4428 4429 /** 4430 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended 4431 * @adapter: address of board private structure 4432 **/ 4433 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter, 4434 struct e1000_rx_ring *rx_ring, 4435 int cleaned_count) 4436 { 4437 struct e1000_hw *hw = &adapter->hw; 4438 struct net_device *netdev = adapter->netdev; 4439 struct pci_dev *pdev = adapter->pdev; 4440 struct e1000_rx_desc *rx_desc; 4441 struct e1000_buffer *buffer_info; 4442 struct sk_buff *skb; 4443 unsigned int i; 4444 unsigned int bufsz = adapter->rx_buffer_len; 4445 4446 i = rx_ring->next_to_use; 4447 buffer_info = &rx_ring->buffer_info[i]; 4448 4449 while (cleaned_count--) { 4450 skb = buffer_info->skb; 4451 if (skb) { 4452 skb_trim(skb, 0); 4453 goto map_skb; 4454 } 4455 4456 skb = netdev_alloc_skb_ip_align(netdev, bufsz); 4457 if (unlikely(!skb)) { 4458 /* Better luck next round */ 4459 adapter->alloc_rx_buff_failed++; 4460 break; 4461 } 4462 4463 /* Fix for errata 23, can't cross 64kB boundary */ 4464 if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) { 4465 struct sk_buff *oldskb = skb; 4466 e_err(rx_err, "skb align check failed: %u bytes at " 4467 "%p\n", bufsz, skb->data); 4468 /* Try again, without freeing the previous */ 4469 skb = netdev_alloc_skb_ip_align(netdev, bufsz); 4470 /* Failed allocation, critical failure */ 4471 if (!skb) { 4472 dev_kfree_skb(oldskb); 4473 adapter->alloc_rx_buff_failed++; 4474 break; 4475 } 4476 4477 if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) { 4478 /* give up */ 4479 dev_kfree_skb(skb); 4480 dev_kfree_skb(oldskb); 4481 adapter->alloc_rx_buff_failed++; 4482 break; /* while !buffer_info->skb */ 4483 } 4484 4485 /* Use new allocation */ 4486 dev_kfree_skb(oldskb); 4487 } 4488 buffer_info->skb = skb; 4489 buffer_info->length = adapter->rx_buffer_len; 4490 map_skb: 4491 buffer_info->dma = dma_map_single(&pdev->dev, 4492 skb->data, 4493 buffer_info->length, 4494 DMA_FROM_DEVICE); 4495 if (dma_mapping_error(&pdev->dev, buffer_info->dma)) { 4496 dev_kfree_skb(skb); 4497 buffer_info->skb = NULL; 4498 buffer_info->dma = 0; 4499 adapter->alloc_rx_buff_failed++; 4500 break; /* while !buffer_info->skb */ 4501 } 4502 4503 /* XXX if it was allocated cleanly it will never map to a 4504 * boundary crossing 4505 */ 4506 4507 /* Fix for errata 23, can't cross 64kB boundary */ 4508 if (!e1000_check_64k_bound(adapter, 4509 (void *)(unsigned long)buffer_info->dma, 4510 adapter->rx_buffer_len)) { 4511 e_err(rx_err, "dma align check failed: %u bytes at " 4512 "%p\n", adapter->rx_buffer_len, 4513 (void *)(unsigned long)buffer_info->dma); 4514 dev_kfree_skb(skb); 4515 buffer_info->skb = NULL; 4516 4517 dma_unmap_single(&pdev->dev, buffer_info->dma, 4518 adapter->rx_buffer_len, 4519 DMA_FROM_DEVICE); 4520 buffer_info->dma = 0; 4521 4522 adapter->alloc_rx_buff_failed++; 4523 break; /* while !buffer_info->skb */ 4524 } 4525 rx_desc = E1000_RX_DESC(*rx_ring, i); 4526 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma); 4527 4528 if (unlikely(++i == rx_ring->count)) 4529 i = 0; 4530 buffer_info = &rx_ring->buffer_info[i]; 4531 } 4532 4533 if (likely(rx_ring->next_to_use != i)) { 4534 rx_ring->next_to_use = i; 4535 if (unlikely(i-- == 0)) 4536 i = (rx_ring->count - 1); 4537 4538 /* Force memory writes to complete before letting h/w 4539 * know there are new descriptors to fetch. (Only 4540 * applicable for weak-ordered memory model archs, 4541 * such as IA-64). 4542 */ 4543 wmb(); 4544 writel(i, hw->hw_addr + rx_ring->rdt); 4545 } 4546 } 4547 4548 /** 4549 * e1000_smartspeed - Workaround for SmartSpeed on 82541 and 82547 controllers. 4550 * @adapter: 4551 **/ 4552 static void e1000_smartspeed(struct e1000_adapter *adapter) 4553 { 4554 struct e1000_hw *hw = &adapter->hw; 4555 u16 phy_status; 4556 u16 phy_ctrl; 4557 4558 if ((hw->phy_type != e1000_phy_igp) || !hw->autoneg || 4559 !(hw->autoneg_advertised & ADVERTISE_1000_FULL)) 4560 return; 4561 4562 if (adapter->smartspeed == 0) { 4563 /* If Master/Slave config fault is asserted twice, 4564 * we assume back-to-back 4565 */ 4566 e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status); 4567 if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return; 4568 e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status); 4569 if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return; 4570 e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl); 4571 if (phy_ctrl & CR_1000T_MS_ENABLE) { 4572 phy_ctrl &= ~CR_1000T_MS_ENABLE; 4573 e1000_write_phy_reg(hw, PHY_1000T_CTRL, 4574 phy_ctrl); 4575 adapter->smartspeed++; 4576 if (!e1000_phy_setup_autoneg(hw) && 4577 !e1000_read_phy_reg(hw, PHY_CTRL, 4578 &phy_ctrl)) { 4579 phy_ctrl |= (MII_CR_AUTO_NEG_EN | 4580 MII_CR_RESTART_AUTO_NEG); 4581 e1000_write_phy_reg(hw, PHY_CTRL, 4582 phy_ctrl); 4583 } 4584 } 4585 return; 4586 } else if (adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) { 4587 /* If still no link, perhaps using 2/3 pair cable */ 4588 e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl); 4589 phy_ctrl |= CR_1000T_MS_ENABLE; 4590 e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_ctrl); 4591 if (!e1000_phy_setup_autoneg(hw) && 4592 !e1000_read_phy_reg(hw, PHY_CTRL, &phy_ctrl)) { 4593 phy_ctrl |= (MII_CR_AUTO_NEG_EN | 4594 MII_CR_RESTART_AUTO_NEG); 4595 e1000_write_phy_reg(hw, PHY_CTRL, phy_ctrl); 4596 } 4597 } 4598 /* Restart process after E1000_SMARTSPEED_MAX iterations */ 4599 if (adapter->smartspeed++ == E1000_SMARTSPEED_MAX) 4600 adapter->smartspeed = 0; 4601 } 4602 4603 /** 4604 * e1000_ioctl - 4605 * @netdev: 4606 * @ifreq: 4607 * @cmd: 4608 **/ 4609 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) 4610 { 4611 switch (cmd) { 4612 case SIOCGMIIPHY: 4613 case SIOCGMIIREG: 4614 case SIOCSMIIREG: 4615 return e1000_mii_ioctl(netdev, ifr, cmd); 4616 default: 4617 return -EOPNOTSUPP; 4618 } 4619 } 4620 4621 /** 4622 * e1000_mii_ioctl - 4623 * @netdev: 4624 * @ifreq: 4625 * @cmd: 4626 **/ 4627 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr, 4628 int cmd) 4629 { 4630 struct e1000_adapter *adapter = netdev_priv(netdev); 4631 struct e1000_hw *hw = &adapter->hw; 4632 struct mii_ioctl_data *data = if_mii(ifr); 4633 int retval; 4634 u16 mii_reg; 4635 unsigned long flags; 4636 4637 if (hw->media_type != e1000_media_type_copper) 4638 return -EOPNOTSUPP; 4639 4640 switch (cmd) { 4641 case SIOCGMIIPHY: 4642 data->phy_id = hw->phy_addr; 4643 break; 4644 case SIOCGMIIREG: 4645 spin_lock_irqsave(&adapter->stats_lock, flags); 4646 if (e1000_read_phy_reg(hw, data->reg_num & 0x1F, 4647 &data->val_out)) { 4648 spin_unlock_irqrestore(&adapter->stats_lock, flags); 4649 return -EIO; 4650 } 4651 spin_unlock_irqrestore(&adapter->stats_lock, flags); 4652 break; 4653 case SIOCSMIIREG: 4654 if (data->reg_num & ~(0x1F)) 4655 return -EFAULT; 4656 mii_reg = data->val_in; 4657 spin_lock_irqsave(&adapter->stats_lock, flags); 4658 if (e1000_write_phy_reg(hw, data->reg_num, 4659 mii_reg)) { 4660 spin_unlock_irqrestore(&adapter->stats_lock, flags); 4661 return -EIO; 4662 } 4663 spin_unlock_irqrestore(&adapter->stats_lock, flags); 4664 if (hw->media_type == e1000_media_type_copper) { 4665 switch (data->reg_num) { 4666 case PHY_CTRL: 4667 if (mii_reg & MII_CR_POWER_DOWN) 4668 break; 4669 if (mii_reg & MII_CR_AUTO_NEG_EN) { 4670 hw->autoneg = 1; 4671 hw->autoneg_advertised = 0x2F; 4672 } else { 4673 u32 speed; 4674 if (mii_reg & 0x40) 4675 speed = SPEED_1000; 4676 else if (mii_reg & 0x2000) 4677 speed = SPEED_100; 4678 else 4679 speed = SPEED_10; 4680 retval = e1000_set_spd_dplx( 4681 adapter, speed, 4682 ((mii_reg & 0x100) 4683 ? DUPLEX_FULL : 4684 DUPLEX_HALF)); 4685 if (retval) 4686 return retval; 4687 } 4688 if (netif_running(adapter->netdev)) 4689 e1000_reinit_locked(adapter); 4690 else 4691 e1000_reset(adapter); 4692 break; 4693 case M88E1000_PHY_SPEC_CTRL: 4694 case M88E1000_EXT_PHY_SPEC_CTRL: 4695 if (e1000_phy_reset(hw)) 4696 return -EIO; 4697 break; 4698 } 4699 } else { 4700 switch (data->reg_num) { 4701 case PHY_CTRL: 4702 if (mii_reg & MII_CR_POWER_DOWN) 4703 break; 4704 if (netif_running(adapter->netdev)) 4705 e1000_reinit_locked(adapter); 4706 else 4707 e1000_reset(adapter); 4708 break; 4709 } 4710 } 4711 break; 4712 default: 4713 return -EOPNOTSUPP; 4714 } 4715 return E1000_SUCCESS; 4716 } 4717 4718 void e1000_pci_set_mwi(struct e1000_hw *hw) 4719 { 4720 struct e1000_adapter *adapter = hw->back; 4721 int ret_val = pci_set_mwi(adapter->pdev); 4722 4723 if (ret_val) 4724 e_err(probe, "Error in setting MWI\n"); 4725 } 4726 4727 void e1000_pci_clear_mwi(struct e1000_hw *hw) 4728 { 4729 struct e1000_adapter *adapter = hw->back; 4730 4731 pci_clear_mwi(adapter->pdev); 4732 } 4733 4734 int e1000_pcix_get_mmrbc(struct e1000_hw *hw) 4735 { 4736 struct e1000_adapter *adapter = hw->back; 4737 return pcix_get_mmrbc(adapter->pdev); 4738 } 4739 4740 void e1000_pcix_set_mmrbc(struct e1000_hw *hw, int mmrbc) 4741 { 4742 struct e1000_adapter *adapter = hw->back; 4743 pcix_set_mmrbc(adapter->pdev, mmrbc); 4744 } 4745 4746 void e1000_io_write(struct e1000_hw *hw, unsigned long port, u32 value) 4747 { 4748 outl(value, port); 4749 } 4750 4751 static bool e1000_vlan_used(struct e1000_adapter *adapter) 4752 { 4753 u16 vid; 4754 4755 for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID) 4756 return true; 4757 return false; 4758 } 4759 4760 static void __e1000_vlan_mode(struct e1000_adapter *adapter, 4761 netdev_features_t features) 4762 { 4763 struct e1000_hw *hw = &adapter->hw; 4764 u32 ctrl; 4765 4766 ctrl = er32(CTRL); 4767 if (features & NETIF_F_HW_VLAN_CTAG_RX) { 4768 /* enable VLAN tag insert/strip */ 4769 ctrl |= E1000_CTRL_VME; 4770 } else { 4771 /* disable VLAN tag insert/strip */ 4772 ctrl &= ~E1000_CTRL_VME; 4773 } 4774 ew32(CTRL, ctrl); 4775 } 4776 static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter, 4777 bool filter_on) 4778 { 4779 struct e1000_hw *hw = &adapter->hw; 4780 u32 rctl; 4781 4782 if (!test_bit(__E1000_DOWN, &adapter->flags)) 4783 e1000_irq_disable(adapter); 4784 4785 __e1000_vlan_mode(adapter, adapter->netdev->features); 4786 if (filter_on) { 4787 /* enable VLAN receive filtering */ 4788 rctl = er32(RCTL); 4789 rctl &= ~E1000_RCTL_CFIEN; 4790 if (!(adapter->netdev->flags & IFF_PROMISC)) 4791 rctl |= E1000_RCTL_VFE; 4792 ew32(RCTL, rctl); 4793 e1000_update_mng_vlan(adapter); 4794 } else { 4795 /* disable VLAN receive filtering */ 4796 rctl = er32(RCTL); 4797 rctl &= ~E1000_RCTL_VFE; 4798 ew32(RCTL, rctl); 4799 } 4800 4801 if (!test_bit(__E1000_DOWN, &adapter->flags)) 4802 e1000_irq_enable(adapter); 4803 } 4804 4805 static void e1000_vlan_mode(struct net_device *netdev, 4806 netdev_features_t features) 4807 { 4808 struct e1000_adapter *adapter = netdev_priv(netdev); 4809 4810 if (!test_bit(__E1000_DOWN, &adapter->flags)) 4811 e1000_irq_disable(adapter); 4812 4813 __e1000_vlan_mode(adapter, features); 4814 4815 if (!test_bit(__E1000_DOWN, &adapter->flags)) 4816 e1000_irq_enable(adapter); 4817 } 4818 4819 static int e1000_vlan_rx_add_vid(struct net_device *netdev, 4820 __be16 proto, u16 vid) 4821 { 4822 struct e1000_adapter *adapter = netdev_priv(netdev); 4823 struct e1000_hw *hw = &adapter->hw; 4824 u32 vfta, index; 4825 4826 if ((hw->mng_cookie.status & 4827 E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) && 4828 (vid == adapter->mng_vlan_id)) 4829 return 0; 4830 4831 if (!e1000_vlan_used(adapter)) 4832 e1000_vlan_filter_on_off(adapter, true); 4833 4834 /* add VID to filter table */ 4835 index = (vid >> 5) & 0x7F; 4836 vfta = E1000_READ_REG_ARRAY(hw, VFTA, index); 4837 vfta |= (1 << (vid & 0x1F)); 4838 e1000_write_vfta(hw, index, vfta); 4839 4840 set_bit(vid, adapter->active_vlans); 4841 4842 return 0; 4843 } 4844 4845 static int e1000_vlan_rx_kill_vid(struct net_device *netdev, 4846 __be16 proto, u16 vid) 4847 { 4848 struct e1000_adapter *adapter = netdev_priv(netdev); 4849 struct e1000_hw *hw = &adapter->hw; 4850 u32 vfta, index; 4851 4852 if (!test_bit(__E1000_DOWN, &adapter->flags)) 4853 e1000_irq_disable(adapter); 4854 if (!test_bit(__E1000_DOWN, &adapter->flags)) 4855 e1000_irq_enable(adapter); 4856 4857 /* remove VID from filter table */ 4858 index = (vid >> 5) & 0x7F; 4859 vfta = E1000_READ_REG_ARRAY(hw, VFTA, index); 4860 vfta &= ~(1 << (vid & 0x1F)); 4861 e1000_write_vfta(hw, index, vfta); 4862 4863 clear_bit(vid, adapter->active_vlans); 4864 4865 if (!e1000_vlan_used(adapter)) 4866 e1000_vlan_filter_on_off(adapter, false); 4867 4868 return 0; 4869 } 4870 4871 static void e1000_restore_vlan(struct e1000_adapter *adapter) 4872 { 4873 u16 vid; 4874 4875 if (!e1000_vlan_used(adapter)) 4876 return; 4877 4878 e1000_vlan_filter_on_off(adapter, true); 4879 for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID) 4880 e1000_vlan_rx_add_vid(adapter->netdev, htons(ETH_P_8021Q), vid); 4881 } 4882 4883 int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx) 4884 { 4885 struct e1000_hw *hw = &adapter->hw; 4886 4887 hw->autoneg = 0; 4888 4889 /* Make sure dplx is at most 1 bit and lsb of speed is not set 4890 * for the switch() below to work 4891 */ 4892 if ((spd & 1) || (dplx & ~1)) 4893 goto err_inval; 4894 4895 /* Fiber NICs only allow 1000 gbps Full duplex */ 4896 if ((hw->media_type == e1000_media_type_fiber) && 4897 spd != SPEED_1000 && 4898 dplx != DUPLEX_FULL) 4899 goto err_inval; 4900 4901 switch (spd + dplx) { 4902 case SPEED_10 + DUPLEX_HALF: 4903 hw->forced_speed_duplex = e1000_10_half; 4904 break; 4905 case SPEED_10 + DUPLEX_FULL: 4906 hw->forced_speed_duplex = e1000_10_full; 4907 break; 4908 case SPEED_100 + DUPLEX_HALF: 4909 hw->forced_speed_duplex = e1000_100_half; 4910 break; 4911 case SPEED_100 + DUPLEX_FULL: 4912 hw->forced_speed_duplex = e1000_100_full; 4913 break; 4914 case SPEED_1000 + DUPLEX_FULL: 4915 hw->autoneg = 1; 4916 hw->autoneg_advertised = ADVERTISE_1000_FULL; 4917 break; 4918 case SPEED_1000 + DUPLEX_HALF: /* not supported */ 4919 default: 4920 goto err_inval; 4921 } 4922 4923 /* clear MDI, MDI(-X) override is only allowed when autoneg enabled */ 4924 hw->mdix = AUTO_ALL_MODES; 4925 4926 return 0; 4927 4928 err_inval: 4929 e_err(probe, "Unsupported Speed/Duplex configuration\n"); 4930 return -EINVAL; 4931 } 4932 4933 static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake) 4934 { 4935 struct net_device *netdev = pci_get_drvdata(pdev); 4936 struct e1000_adapter *adapter = netdev_priv(netdev); 4937 struct e1000_hw *hw = &adapter->hw; 4938 u32 ctrl, ctrl_ext, rctl, status; 4939 u32 wufc = adapter->wol; 4940 #ifdef CONFIG_PM 4941 int retval = 0; 4942 #endif 4943 4944 netif_device_detach(netdev); 4945 4946 if (netif_running(netdev)) { 4947 int count = E1000_CHECK_RESET_COUNT; 4948 4949 while (test_bit(__E1000_RESETTING, &adapter->flags) && count--) 4950 usleep_range(10000, 20000); 4951 4952 WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags)); 4953 e1000_down(adapter); 4954 } 4955 4956 #ifdef CONFIG_PM 4957 retval = pci_save_state(pdev); 4958 if (retval) 4959 return retval; 4960 #endif 4961 4962 status = er32(STATUS); 4963 if (status & E1000_STATUS_LU) 4964 wufc &= ~E1000_WUFC_LNKC; 4965 4966 if (wufc) { 4967 e1000_setup_rctl(adapter); 4968 e1000_set_rx_mode(netdev); 4969 4970 rctl = er32(RCTL); 4971 4972 /* turn on all-multi mode if wake on multicast is enabled */ 4973 if (wufc & E1000_WUFC_MC) 4974 rctl |= E1000_RCTL_MPE; 4975 4976 /* enable receives in the hardware */ 4977 ew32(RCTL, rctl | E1000_RCTL_EN); 4978 4979 if (hw->mac_type >= e1000_82540) { 4980 ctrl = er32(CTRL); 4981 /* advertise wake from D3Cold */ 4982 #define E1000_CTRL_ADVD3WUC 0x00100000 4983 /* phy power management enable */ 4984 #define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000 4985 ctrl |= E1000_CTRL_ADVD3WUC | 4986 E1000_CTRL_EN_PHY_PWR_MGMT; 4987 ew32(CTRL, ctrl); 4988 } 4989 4990 if (hw->media_type == e1000_media_type_fiber || 4991 hw->media_type == e1000_media_type_internal_serdes) { 4992 /* keep the laser running in D3 */ 4993 ctrl_ext = er32(CTRL_EXT); 4994 ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA; 4995 ew32(CTRL_EXT, ctrl_ext); 4996 } 4997 4998 ew32(WUC, E1000_WUC_PME_EN); 4999 ew32(WUFC, wufc); 5000 } else { 5001 ew32(WUC, 0); 5002 ew32(WUFC, 0); 5003 } 5004 5005 e1000_release_manageability(adapter); 5006 5007 *enable_wake = !!wufc; 5008 5009 /* make sure adapter isn't asleep if manageability is enabled */ 5010 if (adapter->en_mng_pt) 5011 *enable_wake = true; 5012 5013 if (netif_running(netdev)) 5014 e1000_free_irq(adapter); 5015 5016 pci_disable_device(pdev); 5017 5018 return 0; 5019 } 5020 5021 #ifdef CONFIG_PM 5022 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state) 5023 { 5024 int retval; 5025 bool wake; 5026 5027 retval = __e1000_shutdown(pdev, &wake); 5028 if (retval) 5029 return retval; 5030 5031 if (wake) { 5032 pci_prepare_to_sleep(pdev); 5033 } else { 5034 pci_wake_from_d3(pdev, false); 5035 pci_set_power_state(pdev, PCI_D3hot); 5036 } 5037 5038 return 0; 5039 } 5040 5041 static int e1000_resume(struct pci_dev *pdev) 5042 { 5043 struct net_device *netdev = pci_get_drvdata(pdev); 5044 struct e1000_adapter *adapter = netdev_priv(netdev); 5045 struct e1000_hw *hw = &adapter->hw; 5046 u32 err; 5047 5048 pci_set_power_state(pdev, PCI_D0); 5049 pci_restore_state(pdev); 5050 pci_save_state(pdev); 5051 5052 if (adapter->need_ioport) 5053 err = pci_enable_device(pdev); 5054 else 5055 err = pci_enable_device_mem(pdev); 5056 if (err) { 5057 pr_err("Cannot enable PCI device from suspend\n"); 5058 return err; 5059 } 5060 pci_set_master(pdev); 5061 5062 pci_enable_wake(pdev, PCI_D3hot, 0); 5063 pci_enable_wake(pdev, PCI_D3cold, 0); 5064 5065 if (netif_running(netdev)) { 5066 err = e1000_request_irq(adapter); 5067 if (err) 5068 return err; 5069 } 5070 5071 e1000_power_up_phy(adapter); 5072 e1000_reset(adapter); 5073 ew32(WUS, ~0); 5074 5075 e1000_init_manageability(adapter); 5076 5077 if (netif_running(netdev)) 5078 e1000_up(adapter); 5079 5080 netif_device_attach(netdev); 5081 5082 return 0; 5083 } 5084 #endif 5085 5086 static void e1000_shutdown(struct pci_dev *pdev) 5087 { 5088 bool wake; 5089 5090 __e1000_shutdown(pdev, &wake); 5091 5092 if (system_state == SYSTEM_POWER_OFF) { 5093 pci_wake_from_d3(pdev, wake); 5094 pci_set_power_state(pdev, PCI_D3hot); 5095 } 5096 } 5097 5098 #ifdef CONFIG_NET_POLL_CONTROLLER 5099 /* Polling 'interrupt' - used by things like netconsole to send skbs 5100 * without having to re-enable interrupts. It's not called while 5101 * the interrupt routine is executing. 5102 */ 5103 static void e1000_netpoll(struct net_device *netdev) 5104 { 5105 struct e1000_adapter *adapter = netdev_priv(netdev); 5106 5107 disable_irq(adapter->pdev->irq); 5108 e1000_intr(adapter->pdev->irq, netdev); 5109 enable_irq(adapter->pdev->irq); 5110 } 5111 #endif 5112 5113 /** 5114 * e1000_io_error_detected - called when PCI error is detected 5115 * @pdev: Pointer to PCI device 5116 * @state: The current pci connection state 5117 * 5118 * This function is called after a PCI bus error affecting 5119 * this device has been detected. 5120 */ 5121 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev, 5122 pci_channel_state_t state) 5123 { 5124 struct net_device *netdev = pci_get_drvdata(pdev); 5125 struct e1000_adapter *adapter = netdev_priv(netdev); 5126 5127 netif_device_detach(netdev); 5128 5129 if (state == pci_channel_io_perm_failure) 5130 return PCI_ERS_RESULT_DISCONNECT; 5131 5132 if (netif_running(netdev)) 5133 e1000_down(adapter); 5134 pci_disable_device(pdev); 5135 5136 /* Request a slot slot reset. */ 5137 return PCI_ERS_RESULT_NEED_RESET; 5138 } 5139 5140 /** 5141 * e1000_io_slot_reset - called after the pci bus has been reset. 5142 * @pdev: Pointer to PCI device 5143 * 5144 * Restart the card from scratch, as if from a cold-boot. Implementation 5145 * resembles the first-half of the e1000_resume routine. 5146 */ 5147 static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev) 5148 { 5149 struct net_device *netdev = pci_get_drvdata(pdev); 5150 struct e1000_adapter *adapter = netdev_priv(netdev); 5151 struct e1000_hw *hw = &adapter->hw; 5152 int err; 5153 5154 if (adapter->need_ioport) 5155 err = pci_enable_device(pdev); 5156 else 5157 err = pci_enable_device_mem(pdev); 5158 if (err) { 5159 pr_err("Cannot re-enable PCI device after reset.\n"); 5160 return PCI_ERS_RESULT_DISCONNECT; 5161 } 5162 pci_set_master(pdev); 5163 5164 pci_enable_wake(pdev, PCI_D3hot, 0); 5165 pci_enable_wake(pdev, PCI_D3cold, 0); 5166 5167 e1000_reset(adapter); 5168 ew32(WUS, ~0); 5169 5170 return PCI_ERS_RESULT_RECOVERED; 5171 } 5172 5173 /** 5174 * e1000_io_resume - called when traffic can start flowing again. 5175 * @pdev: Pointer to PCI device 5176 * 5177 * This callback is called when the error recovery driver tells us that 5178 * its OK to resume normal operation. Implementation resembles the 5179 * second-half of the e1000_resume routine. 5180 */ 5181 static void e1000_io_resume(struct pci_dev *pdev) 5182 { 5183 struct net_device *netdev = pci_get_drvdata(pdev); 5184 struct e1000_adapter *adapter = netdev_priv(netdev); 5185 5186 e1000_init_manageability(adapter); 5187 5188 if (netif_running(netdev)) { 5189 if (e1000_up(adapter)) { 5190 pr_info("can't bring device back up after reset\n"); 5191 return; 5192 } 5193 } 5194 5195 netif_device_attach(netdev); 5196 } 5197 5198 /* e1000_main.c */ 5199