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