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